From fd59e9aedee09c8d8ef3faa26e77ed5928bf3b39 Mon Sep 17 00:00:00 2001 From: Anthony Rueda Date: Thu, 22 Sep 2022 13:44:49 -0700 Subject: [PATCH] Consolidate credential_storage callback functions. Move all callback struct definitions in a central header file compiled as part of internal/platform/implementation:comm library. PiperOrigin-RevId: 476186596 --- internal/platform/credential_storage_impl.cc | 21 +- internal/platform/credential_storage_impl.h | 29 +- .../platform/credential_storage_impl_test.cc | 309 +++++++++++++----- internal/platform/implementation/BUILD | 1 + .../implementation/credential_callbacks.h | 68 ++++ .../implementation/credential_storage.h | 48 +-- .../g3/credential_storage_impl.cc | 91 ++++-- .../g3/credential_storage_impl.h | 33 +- presence/implementation/credential_manager.h | 21 +- .../implementation/credential_manager_impl.cc | 19 +- .../implementation/credential_manager_impl.h | 12 +- .../credential_manager_impl_test.cc | 22 +- 12 files changed, 429 insertions(+), 245 deletions(-) create mode 100644 internal/platform/implementation/credential_callbacks.h diff --git a/internal/platform/credential_storage_impl.cc b/internal/platform/credential_storage_impl.cc index 584f5319..a78b19ef 100644 --- a/internal/platform/credential_storage_impl.cc +++ b/internal/platform/credential_storage_impl.cc @@ -16,33 +16,40 @@ #include #include +#include "internal/platform/implementation/credential_callbacks.h" + namespace location { namespace nearby { using ::nearby::internal::PrivateCredential; using ::nearby::internal::PublicCredential; +using ::nearby::presence::CredentialSelector; +using ::nearby::presence::GenerateCredentialsCallback; +using ::nearby::presence::GetPrivateCredentialsResultCallback; +using ::nearby::presence::GetPublicCredentialsResultCallback; +using ::nearby::presence::PublicCredentialType; void CredentialStorageImpl::SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, const std::vector& private_credentials, const std::vector& public_credentials, - api::PublicCredentialType public_credential_type, - api::SaveCredentialsResultCallback callback) { + PublicCredentialType public_credential_type, + GenerateCredentialsCallback callback) { return impl_->SaveCredentials(manager_app_id, account_name, private_credentials, public_credentials, public_credential_type, std::move(callback)); } void CredentialStorageImpl::GetPrivateCredentials( - const api::CredentialSelector& credential_selector, - api::GetPrivateCredentialsResultCallback callback) { + const CredentialSelector& credential_selector, + GetPrivateCredentialsResultCallback callback) { return impl_->GetPrivateCredentials(credential_selector, std::move(callback)); } void CredentialStorageImpl::GetPublicCredentials( - const api::CredentialSelector& credential_selector, - api::PublicCredentialType public_credential_type, - api::GetPublicCredentialsResultCallback callback) { + const CredentialSelector& credential_selector, + PublicCredentialType public_credential_type, + GetPublicCredentialsResultCallback callback) { return impl_->GetPublicCredentials( credential_selector, public_credential_type, std::move(callback)); } diff --git a/internal/platform/credential_storage_impl.h b/internal/platform/credential_storage_impl.h index cfe69985..79e80109 100644 --- a/internal/platform/credential_storage_impl.h +++ b/internal/platform/credential_storage_impl.h @@ -16,9 +16,11 @@ #define THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_CREDENTIAL_STORAGE_IMPL_H_ #include +#include #include #include "absl/strings/string_view.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/platform/implementation/credential_storage.h" #include "internal/platform/implementation/platform.h" @@ -39,25 +41,26 @@ class CredentialStorageImpl : public api::CredentialStorage { CredentialStorageImpl(CredentialStorageImpl&& other) = default; CredentialStorageImpl& operator=(CredentialStorageImpl&& other) = default; - void SaveCredentials(absl::string_view manager_app_id, - absl::string_view account_name, - const std::vector<::nearby::internal::PrivateCredential>& - private_credentials, - const std::vector<::nearby::internal::PublicCredential>& - public_credentials, - api::PublicCredentialType public_credential_type, - api::SaveCredentialsResultCallback callback) override; + void SaveCredentials( + absl::string_view manager_app_id, absl::string_view account_name, + const std::vector<::nearby::internal::PrivateCredential>& + private_credentials, + const std::vector<::nearby::internal::PublicCredential>& + public_credentials, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GenerateCredentialsCallback callback) override; // Used to fetch private creds when broadcasting. void GetPrivateCredentials( - const api::CredentialSelector& credential_selector, - api::GetPrivateCredentialsResultCallback callback) override; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::GetPrivateCredentialsResultCallback callback) + override; // Used to fetch remote public creds when scanning. void GetPublicCredentials( - const api::CredentialSelector& credential_selector, - api::PublicCredentialType public_credential_type, - api::GetPublicCredentialsResultCallback callback) override; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GetPublicCredentialsResultCallback callback) override; private: std::unique_ptr impl_; diff --git a/internal/platform/credential_storage_impl_test.cc b/internal/platform/credential_storage_impl_test.cc index 7a97eeb9..f76d5c6a 100644 --- a/internal/platform/credential_storage_impl_test.cc +++ b/internal/platform/credential_storage_impl_test.cc @@ -15,140 +15,277 @@ #include "internal/platform/credential_storage_impl.h" #include +#include #include #include #include #include #include "gtest/gtest.h" +#include "absl/strings/string_view.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/proto/credential.pb.h" +#include "internal/proto/credential.proto.h" namespace location { namespace nearby { +namespace { using ::nearby::internal::PrivateCredential; using ::nearby::internal::PublicCredential; +using ::nearby::presence::CredentialOperationStatus; +using ::nearby::presence::CredentialSelector; +using ::nearby::presence::GenerateCredentialsCallback; +using ::nearby::presence::GetPrivateCredentialsResultCallback; +using ::nearby::presence::GetPublicCredentialsResultCallback; +using ::nearby::presence::PublicCredentialType; + +std::vector BuildDefaultPrivateCreds() { + PrivateCredential private_credential; + private_credential.set_secret_id("secret_id"); + std::vector private_credentials; + private_credentials.push_back(private_credential); + return private_credentials; +} + +std::vector BuildDefaultPublicCreds() { + PublicCredential public_credential; + public_credential.set_secret_id("secret_id"); + std::vector public_credentials; + public_credentials.push_back(public_credential); + return public_credentials; +} + +CredentialSelector BuildDefaultCredentialSelector() { + constexpr absl::string_view kAppId = "0192"; + constexpr absl::string_view kAccountName = "test_account"; + CredentialSelector credential_selector; + credential_selector.manager_app_id = kAppId; + credential_selector.account_name = kAccountName; + return credential_selector; +} TEST(CredentialStorageImplTest, CanSaveAndGetPrivateCredentials) { - // Define mock parameters - std::string manager_app_id{"0192"}; - std::string account_name{"test_account"}; - api::CredentialSelector credential_selector; - credential_selector.manager_app_id = manager_app_id; - credential_selector.account_name = account_name; - api::PublicCredentialType public_credential_type{ - api::PublicCredentialType::kLocalPublicCredential}; - // Create mock credentials - PrivateCredential private_credential; - PublicCredential public_credential; - private_credential.set_secret_id("secret_id"); - public_credential.set_secret_id("secret_id"); - std::vector private_credentials; - std::vector public_credentials; - private_credentials.push_back(private_credential); - public_credentials.push_back(public_credential); - // Define SaveCredentialsResultCallback - bool successfull_save{false}; - api::SaveCredentialsResultCallback save_creds_callback; - save_creds_callback.credentials_saved_cb = - [&successfull_save](api::CredentialOperationStatus status) { - if (status == api::CredentialOperationStatus::kSucceeded) { + std::vector default_private_creds = + BuildDefaultPrivateCreds(); + std::vector default_public_creds = + BuildDefaultPublicCreds(); + std::vector empty_private_creds; + std::vector empty_public_creds; + bool successfull_save = false; + GenerateCredentialsCallback generate_creds_callback; + generate_creds_callback.credentials_generated_cb = + [&successfull_save, &default_public_creds]( + const std::vector& public_creds) { + if (public_creds[0].secret_id() == + default_public_creds[0].secret_id()) { successfull_save = true; } }; - // Define GetPrivateCredentialsResultCallback - bool get_private_cred_succeeded{false}; - api::GetPrivateCredentialsResultCallback get_private_creds_callback; + std::vector retrieved_creds; + GetPrivateCredentialsResultCallback get_private_creds_callback; get_private_creds_callback.credentials_fetched_cb = - [&private_credentials, &get_private_cred_succeeded]( - const std::vector &private_creds) { - auto private_cred = private_creds[0]; - auto private_credential = private_credentials[0]; - if (private_cred.secret_id() == private_credential.secret_id()) { - get_private_cred_succeeded = true; - } + [&retrieved_creds](const std::vector& private_creds) { + retrieved_creds = private_creds; }; + bool get_private_cred_failed = false; get_private_creds_callback.get_credentials_failed_cb = - [&get_private_cred_succeeded](api::CredentialOperationStatus status) { - if (status == api::CredentialOperationStatus::kFailed) { - get_private_cred_succeeded = false; + [&get_private_cred_failed](CredentialOperationStatus status) { + if (status == CredentialOperationStatus::kFailed) { + get_private_cred_failed = true; } }; // Create CredentialStorageImpl object to test SaveCredentials & // GetPrivateCredentials + CredentialSelector cred_selector = BuildDefaultCredentialSelector(); + PublicCredentialType public_credential_type = + PublicCredentialType::kLocalPublicCredential; CredentialStorageImpl creds_storage; - creds_storage.GetPrivateCredentials(credential_selector, + creds_storage.GetPrivateCredentials(cred_selector, get_private_creds_callback); - EXPECT_FALSE(get_private_cred_succeeded); + EXPECT_TRUE(get_private_cred_failed); + creds_storage.SaveCredentials(cred_selector.manager_app_id, + cred_selector.account_name, empty_private_creds, + empty_public_creds, public_credential_type, + generate_creds_callback); + EXPECT_FALSE(successfull_save); creds_storage.SaveCredentials( - manager_app_id, account_name, private_credentials, public_credentials, - public_credential_type, std::move(save_creds_callback)); + cred_selector.manager_app_id, cred_selector.account_name, + default_private_creds, empty_public_creds, public_credential_type, + generate_creds_callback); + EXPECT_FALSE(successfull_save); + creds_storage.SaveCredentials( + cred_selector.manager_app_id, cred_selector.account_name, + default_private_creds, default_public_creds, public_credential_type, + std::move(generate_creds_callback)); EXPECT_TRUE(successfull_save); - creds_storage.GetPrivateCredentials(credential_selector, + creds_storage.GetPrivateCredentials(cred_selector, std::move(get_private_creds_callback)); - EXPECT_TRUE(get_private_cred_succeeded); + EXPECT_EQ(retrieved_creds.size(), 1); } TEST(CredentialStorageImplTest, CanSaveAndGetPublicCredentials) { - // Define mock parameters - std::string manager_app_id{"0192"}; - std::string account_name{"test_account"}; - api::CredentialSelector credential_selector; - credential_selector.manager_app_id = manager_app_id; - credential_selector.account_name = account_name; - api::PublicCredentialType public_credential_type{ - api::PublicCredentialType::kLocalPublicCredential}; - // Create mock credentials - PrivateCredential private_credential; - PublicCredential public_credential; - private_credential.set_secret_id("secret_id"); - public_credential.set_secret_id("secret_id"); - std::vector private_credentials; - std::vector public_credentials; - private_credentials.push_back(private_credential); - public_credentials.push_back(public_credential); - // Define SaveCredentialsResultCallback - bool successfull_save{false}; - api::SaveCredentialsResultCallback save_creds_callback; - save_creds_callback.credentials_saved_cb = - [&successfull_save](api::CredentialOperationStatus status) { - if (status == api::CredentialOperationStatus::kSucceeded) { + std::vector default_private_creds = + BuildDefaultPrivateCreds(); + std::vector default_public_creds = + BuildDefaultPublicCreds(); + std::vector empty_private_creds; + std::vector empty_public_creds; + bool successfull_save = false; + GenerateCredentialsCallback generate_creds_callback; + generate_creds_callback.credentials_generated_cb = + [&successfull_save, &default_public_creds]( + const std::vector& public_creds) { + if (public_creds[0].secret_id() == + default_public_creds[0].secret_id()) { successfull_save = true; } }; - // Define GetPublicCredentialsResultCallback - bool get_public_cred_succeeded{false}; - api::GetPublicCredentialsResultCallback get_public_creds_callback; + std::vector retrieved_creds; + GetPublicCredentialsResultCallback get_public_creds_callback; get_public_creds_callback.credentials_fetched_cb = - [&public_credentials, &get_public_cred_succeeded]( - const std::vector &public_creds) { - auto public_cred = public_creds[0]; - auto public_credential = public_credentials[0]; - if (public_cred.secret_id() == public_credential.secret_id()) { - get_public_cred_succeeded = true; - } + [&retrieved_creds](const std::vector& public_creds) { + retrieved_creds = public_creds; }; + bool get_public_cred_failed = false; get_public_creds_callback.get_credentials_failed_cb = - [&get_public_cred_succeeded](api::CredentialOperationStatus status) { - if (status == api::CredentialOperationStatus::kFailed) { - get_public_cred_succeeded = false; + [&get_public_cred_failed](CredentialOperationStatus status) { + if (status == CredentialOperationStatus::kFailed) { + get_public_cred_failed = true; } }; // Create CredentialStorageImpl object to test SaveCredentials & // GetPublicCredentials + CredentialSelector cred_selector = BuildDefaultCredentialSelector(); + PublicCredentialType public_credential_type = + PublicCredentialType::kLocalPublicCredential; CredentialStorageImpl creds_storage; - creds_storage.GetPublicCredentials( - credential_selector, public_credential_type, get_public_creds_callback); - EXPECT_FALSE(get_public_cred_succeeded); + creds_storage.GetPublicCredentials(cred_selector, public_credential_type, + get_public_creds_callback); + EXPECT_TRUE(get_public_cred_failed); + creds_storage.SaveCredentials(cred_selector.manager_app_id, + cred_selector.account_name, empty_private_creds, + empty_public_creds, public_credential_type, + generate_creds_callback); + EXPECT_FALSE(successfull_save); creds_storage.SaveCredentials( - manager_app_id, account_name, private_credentials, public_credentials, - public_credential_type, std::move(save_creds_callback)); + cred_selector.manager_app_id, cred_selector.account_name, + default_private_creds, empty_public_creds, public_credential_type, + generate_creds_callback); + EXPECT_FALSE(successfull_save); + creds_storage.SaveCredentials( + cred_selector.manager_app_id, cred_selector.account_name, + default_private_creds, default_public_creds, public_credential_type, + std::move(generate_creds_callback)); EXPECT_TRUE(successfull_save); - creds_storage.GetPublicCredentials(credential_selector, - public_credential_type, + creds_storage.GetPublicCredentials(cred_selector, public_credential_type, std::move(get_public_creds_callback)); - EXPECT_TRUE(get_public_cred_succeeded); + EXPECT_EQ(retrieved_creds.size(), 1); } +TEST(CredentialStorageImplTest, OverwritePrivateCredentials) { + std::vector default_priv_creds = + BuildDefaultPrivateCreds(); + std::vector default_pub_creds = BuildDefaultPublicCreds(); + PrivateCredential overwrite_priv_cred; + overwrite_priv_cred.set_secret_id("overwrite_secret_id"); + std::vector overwrite_priv_creds; + overwrite_priv_creds.push_back(overwrite_priv_cred); + std::vector generated_creds; + GenerateCredentialsCallback generate_creds_callback; + generate_creds_callback.credentials_generated_cb = + [&generated_creds](const std::vector& public_creds) { + generated_creds = public_creds; + }; + std::vector retrieved_creds; + GetPrivateCredentialsResultCallback get_private_creds_callback; + get_private_creds_callback.credentials_fetched_cb = + [&retrieved_creds](const std::vector& private_creds) { + retrieved_creds = private_creds; + }; + bool get_private_cred_failed = false; + get_private_creds_callback.get_credentials_failed_cb = + [&get_private_cred_failed](CredentialOperationStatus status) { + if (status == CredentialOperationStatus::kFailed) { + get_private_cred_failed = true; + } + }; + // Create CredentialStorageImpl object to test SaveCredentials & + // GetPrivateCredentials + CredentialSelector cred_selector = BuildDefaultCredentialSelector(); + PublicCredentialType public_credential_type = + PublicCredentialType::kLocalPublicCredential; + CredentialStorageImpl creds_storage; + creds_storage.SaveCredentials(cred_selector.manager_app_id, + cred_selector.account_name, default_priv_creds, + default_pub_creds, public_credential_type, + generate_creds_callback); + EXPECT_EQ(generated_creds[0].secret_id(), default_pub_creds[0].secret_id()); + creds_storage.GetPrivateCredentials(cred_selector, + get_private_creds_callback); + EXPECT_EQ(retrieved_creds[0].secret_id(), default_priv_creds[0].secret_id()); + creds_storage.SaveCredentials( + cred_selector.manager_app_id, cred_selector.account_name, + overwrite_priv_creds, default_pub_creds, public_credential_type, + generate_creds_callback); + EXPECT_EQ(generated_creds[0].secret_id(), default_pub_creds[0].secret_id()); + creds_storage.GetPrivateCredentials(cred_selector, + get_private_creds_callback); + EXPECT_EQ(retrieved_creds[0].secret_id(), + overwrite_priv_creds[0].secret_id()); +} + +TEST(CredentialStorageImplTest, OverwritePublicCredentials) { + std::vector default_priv_creds = + BuildDefaultPrivateCreds(); + std::vector default_pub_creds = BuildDefaultPublicCreds(); + PublicCredential overwrite_pub_cred; + overwrite_pub_cred.set_secret_id("overwrite_secret_id"); + std::vector overwrite_pub_creds; + overwrite_pub_creds.push_back(overwrite_pub_cred); + std::vector generated_creds; + GenerateCredentialsCallback generate_creds_callback; + generate_creds_callback.credentials_generated_cb = + [&generated_creds](const std::vector& public_creds) { + generated_creds = public_creds; + }; + std::vector retrieved_creds; + GetPublicCredentialsResultCallback get_public_creds_callback; + get_public_creds_callback.credentials_fetched_cb = + [&retrieved_creds](const std::vector& public_creds) { + retrieved_creds = public_creds; + }; + bool get_public_cred_failed = false; + get_public_creds_callback.get_credentials_failed_cb = + [&get_public_cred_failed](CredentialOperationStatus status) { + if (status == CredentialOperationStatus::kFailed) { + get_public_cred_failed = true; + } + }; + // Create CredentialStorageImpl object to test SaveCredentials & + // GetPublicCredentials + CredentialSelector cred_selector = BuildDefaultCredentialSelector(); + PublicCredentialType public_credential_type = + PublicCredentialType::kLocalPublicCredential; + CredentialStorageImpl creds_storage; + creds_storage.SaveCredentials(cred_selector.manager_app_id, + cred_selector.account_name, default_priv_creds, + default_pub_creds, public_credential_type, + generate_creds_callback); + EXPECT_EQ(generated_creds[0].secret_id(), default_pub_creds[0].secret_id()); + creds_storage.GetPublicCredentials(cred_selector, public_credential_type, + get_public_creds_callback); + EXPECT_EQ(retrieved_creds[0].secret_id(), default_pub_creds[0].secret_id()); + creds_storage.SaveCredentials(cred_selector.manager_app_id, + cred_selector.account_name, default_priv_creds, + overwrite_pub_creds, public_credential_type, + generate_creds_callback); + EXPECT_EQ(generated_creds[0].secret_id(), overwrite_pub_creds[0].secret_id()); + creds_storage.GetPublicCredentials(cred_selector, public_credential_type, + get_public_creds_callback); + EXPECT_EQ(retrieved_creds[0].secret_id(), overwrite_pub_creds[0].secret_id()); +} + +} // namespace } // namespace nearby } // namespace location diff --git a/internal/platform/implementation/BUILD b/internal/platform/implementation/BUILD index 28950cb6..c69760af 100644 --- a/internal/platform/implementation/BUILD +++ b/internal/platform/implementation/BUILD @@ -57,6 +57,7 @@ cc_library( "ble_v2.h", "bluetooth_adapter.h", "bluetooth_classic.h", + "credential_callbacks.h", "credential_storage.h", "server_sync.h", "wifi.h", diff --git a/internal/platform/implementation/credential_callbacks.h b/internal/platform/implementation/credential_callbacks.h new file mode 100644 index 00000000..eaa2e363 --- /dev/null +++ b/internal/platform/implementation/credential_callbacks.h @@ -0,0 +1,68 @@ +// 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 THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_IMPLEMENTATION_CREDENTIAL_CALLBACKS_H_ +#define THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_IMPLEMENTATION_CREDENTIAL_CALLBACKS_H_ + +#include +#include +#include + +#include "absl/strings/string_view.h" +#include "internal/proto/credential.pb.h" + +namespace nearby { +namespace presence { + +enum class CredentialOperationStatus { + kUnknown = 0, + kFailed = 1, + kSucceeded = 2, +}; + +struct CredentialSelector { + std::string manager_app_id; + std::string account_name; + ::nearby::internal::IdentityType identity_type; +}; + +enum PublicCredentialType { + kLocalPublicCredential = 1, + kRemotePublicCredential = 2, +}; + +struct GenerateCredentialsCallback { + std::function)> + credentials_generated_cb; +}; + +struct UpdateRemotePublicCredentialsCallback { + std::function credentials_updated_cb; +}; + +struct GetPrivateCredentialsResultCallback { + std::function)> + credentials_fetched_cb; + std::function get_credentials_failed_cb; +}; + +struct GetPublicCredentialsResultCallback { + std::function)> + credentials_fetched_cb; + std::function get_credentials_failed_cb; +}; +} // namespace presence +} // namespace nearby + +#endif // THIRD_PARTY_NEARBY_INTERNAL_PLATFORM_IMPLEMENTATION_CREDENTIAL_CALLBACKS_H_ diff --git a/internal/platform/implementation/credential_storage.h b/internal/platform/implementation/credential_storage.h index 39c75ca3..6372236b 100644 --- a/internal/platform/implementation/credential_storage.h +++ b/internal/platform/implementation/credential_storage.h @@ -20,45 +20,13 @@ #include #include "absl/strings/string_view.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/proto/credential.pb.h" namespace location { namespace nearby { namespace api { -enum class CredentialOperationStatus { - kUnknown = 0, - kFailed = 1, - kSucceeded = 2, -}; - -struct CredentialSelector { - std::string manager_app_id; - std::string account_name; - ::nearby::internal::IdentityType identity_type; -}; - -enum PublicCredentialType { - kLocalPublicCredential = 1, - kRemotePublicCredential = 2, -}; - -struct SaveCredentialsResultCallback { - std::function credentials_saved_cb; -}; - -struct GetPrivateCredentialsResultCallback { - std::function)> - credentials_fetched_cb; - std::function get_credentials_failed_cb; -}; - -struct GetPublicCredentialsResultCallback { - std::function)> - credentials_fetched_cb; - std::function get_credentials_failed_cb; -}; - /* * This class specifies the virtual functions for native platforms to implement. */ @@ -76,19 +44,19 @@ class CredentialStorage { private_credentials, const std::vector<::nearby::internal::PublicCredential>& public_credentials, - PublicCredentialType public_credential_type, - SaveCredentialsResultCallback callback) = 0; + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GenerateCredentialsCallback callback) = 0; // Used to fetch private creds when broadcasting. virtual void GetPrivateCredentials( - const CredentialSelector& credential_selector, - GetPrivateCredentialsResultCallback callback) = 0; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::GetPrivateCredentialsResultCallback callback) = 0; // Used to fetch remote public creds when scanning. virtual void GetPublicCredentials( - const CredentialSelector& credential_selector, - PublicCredentialType public_credential_type, - GetPublicCredentialsResultCallback callback) = 0; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GetPublicCredentialsResultCallback callback) = 0; }; } // namespace api diff --git a/internal/platform/implementation/g3/credential_storage_impl.cc b/internal/platform/implementation/g3/credential_storage_impl.cc index 46f2fbdd..d56e024b 100644 --- a/internal/platform/implementation/g3/credential_storage_impl.cc +++ b/internal/platform/implementation/g3/credential_storage_impl.cc @@ -32,47 +32,71 @@ void CredentialStorageImpl::SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, const std::vector& private_credentials, const std::vector& public_credentials, - api::PublicCredentialType public_credential_type, - api::SaveCredentialsResultCallback callback) { + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GenerateCredentialsCallback callback) { NEARBY_LOGS(INFO) << "G3 Save Private Credentials for account: " - << account_name; - auto private_key_value = std::make_pair( - std::make_pair(manager_app_id, account_name), private_credentials); - auto private_res = private_credentials_map_.insert(private_key_value); - if (!private_res.second) { - NEARBY_LOGS(WARNING) - << "Credentials already saved in map. Overriding previous creds!"; - private_credentials_map_[std::make_pair(manager_app_id, account_name)] = - private_credentials; + << account_name << "], manager app ID:[" << manager_app_id + << "]"; + if (private_credentials.empty()) { + NEARBY_LOGS(INFO) << "There are no Private Credentials for account: " + << account_name << "], manager app ID:[" << manager_app_id + << "]"; + return; + } + { + absl::MutexLock lock(&private_mutex_); + auto private_key_value = std::make_pair( + std::make_pair(manager_app_id, account_name), private_credentials); + auto private_result = private_credentials_map_.insert(private_key_value); + if (!private_result.second) { + NEARBY_LOGS(WARNING) + << "Credentials already saved in map. Overwriting previous creds!"; + private_credentials_map_[std::make_pair(manager_app_id, account_name)] = + private_credentials; + } } NEARBY_LOGS(INFO) << "G3 Save Public Credentials for account: " - << account_name; - auto public_key_value = std::make_pair( - std::make_tuple(manager_app_id, account_name, public_credential_type), - public_credentials); - auto public_res = public_credentials_map_.insert(public_key_value); - if (!public_res.second) { - NEARBY_LOGS(WARNING) - << "Credentials already saved in map. Overriding previous creds!"; - public_credentials_map_[std::make_tuple(manager_app_id, account_name, - public_credential_type)] = - public_credentials; + << account_name << "], manager app ID:[" << manager_app_id + << "]"; + if (public_credentials.empty()) { + NEARBY_LOGS(INFO) << "There are no Public Credentials for account: " + << account_name << "], manager app ID:[" << manager_app_id + << "]"; + return; } - callback.credentials_saved_cb(api::CredentialOperationStatus::kSucceeded); + { + absl::MutexLock lock(&public_mutex_); + auto public_key_value = std::make_pair( + std::make_tuple(manager_app_id, account_name, public_credential_type), + public_credentials); + auto public_result = public_credentials_map_.insert(public_key_value); + if (!public_result.second) { + NEARBY_LOGS(WARNING) + << "Credentials already saved in map. Overwriting previous creds!"; + public_credentials_map_[std::make_tuple(manager_app_id, account_name, + public_credential_type)] = + public_credentials; + } + } + + callback.credentials_generated_cb(public_credentials); } void CredentialStorageImpl::GetPrivateCredentials( - const api::CredentialSelector& credential_selector, - api::GetPrivateCredentialsResultCallback callback) { + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::GetPrivateCredentialsResultCallback callback) { NEARBY_LOGS(INFO) << "G3 Get Private Credentials for account: " - << credential_selector.account_name; + << credential_selector.account_name << "], manager app ID:[" + << credential_selector.manager_app_id << "]"; + absl::MutexLock lock(&private_mutex_); auto key = std::make_pair(credential_selector.manager_app_id, credential_selector.account_name); if (private_credentials_map_.find(key) == private_credentials_map_.end()) { NEARBY_LOGS(WARNING) << "There are no Private Credentials stored for key:" << std::get<0>(key) << ", " << std::get<1>(key); - callback.get_credentials_failed_cb(api::CredentialOperationStatus::kFailed); + callback.get_credentials_failed_cb( + ::nearby::presence::CredentialOperationStatus::kFailed); } else { std::vector private_credentials = private_credentials_map_[key]; @@ -81,11 +105,13 @@ void CredentialStorageImpl::GetPrivateCredentials( } void CredentialStorageImpl::GetPublicCredentials( - const api::CredentialSelector& credential_selector, - api::PublicCredentialType public_credential_type, - api::GetPublicCredentialsResultCallback callback) { + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GetPublicCredentialsResultCallback callback) { NEARBY_LOGS(INFO) << "G3 Get Public Credentials for account: " - << credential_selector.account_name; + << credential_selector.account_name << "], manager app ID:[" + << credential_selector.manager_app_id << "]"; + absl::MutexLock lock(&public_mutex_); auto key = std::make_tuple(credential_selector.manager_app_id, credential_selector.account_name, public_credential_type); @@ -93,7 +119,8 @@ void CredentialStorageImpl::GetPublicCredentials( NEARBY_LOGS(WARNING) << "There are no Public Credentials stored for key:" << std::get<0>(key) << ", " << std::get<1>(key) << ", " << std::get<2>(key); - callback.get_credentials_failed_cb(api::CredentialOperationStatus::kFailed); + callback.get_credentials_failed_cb( + ::nearby::presence::CredentialOperationStatus::kFailed); } else { std::vector public_credentials = public_credentials_map_[key]; diff --git a/internal/platform/implementation/g3/credential_storage_impl.h b/internal/platform/implementation/g3/credential_storage_impl.h index 1c0e7bcf..b823deb8 100644 --- a/internal/platform/implementation/g3/credential_storage_impl.h +++ b/internal/platform/implementation/g3/credential_storage_impl.h @@ -22,6 +22,8 @@ #include "absl/container/flat_hash_map.h" #include "absl/strings/string_view.h" +#include "absl/synchronization/mutex.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/platform/implementation/credential_storage.h" #include "internal/proto/credential.proto.h" @@ -40,34 +42,37 @@ class CredentialStorageImpl : public api::CredentialStorage { ~CredentialStorageImpl() override = default; // Used to save private and public credentials. - void SaveCredentials(absl::string_view manager_app_id, - absl::string_view account_name, - const std::vector<::nearby::internal::PrivateCredential>& - private_credentials, - const std::vector<::nearby::internal::PublicCredential>& - public_credentials, - api::PublicCredentialType public_credential_type, - api::SaveCredentialsResultCallback callback) override; + void SaveCredentials( + absl::string_view manager_app_id, absl::string_view account_name, + const std::vector<::nearby::internal::PrivateCredential>& + private_credentials, + const std::vector<::nearby::internal::PublicCredential>& + public_credentials, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GenerateCredentialsCallback callback) override; // Used to fetch private creds when broadcasting. void GetPrivateCredentials( - const api::CredentialSelector& credential_selector, - api::GetPrivateCredentialsResultCallback callback) override; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::GetPrivateCredentialsResultCallback callback) + override; // Used to fetch remote public creds when scanning. void GetPublicCredentials( - const api::CredentialSelector& credential_selector, - api::PublicCredentialType public_credential_type, - api::GetPublicCredentialsResultCallback callback) override; + const ::nearby::presence::CredentialSelector& credential_selector, + ::nearby::presence::PublicCredentialType public_credential_type, + ::nearby::presence::GetPublicCredentialsResultCallback callback) override; private: absl::flat_hash_map, std::vector<::nearby::internal::PrivateCredential>> private_credentials_map_; absl::flat_hash_map, + ::nearby::presence::PublicCredentialType>, std::vector<::nearby::internal::PublicCredential>> public_credentials_map_; + absl::Mutex private_mutex_; + absl::Mutex public_mutex_; }; } // namespace g3 diff --git a/presence/implementation/credential_manager.h b/presence/implementation/credential_manager.h index 8166df25..8d7ae283 100644 --- a/presence/implementation/credential_manager.h +++ b/presence/implementation/credential_manager.h @@ -21,22 +21,12 @@ #include "absl/status/statusor.h" #include "absl/strings/string_view.h" -#include "internal/platform/implementation/credential_storage.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/proto/credential.pb.h" namespace nearby { namespace presence { -struct GenerateCredentialsCallback { - std::function)> - credentials_generated_cb; -}; - -struct UpdateRemotePublicCredentialsCallback { - std::function - credentials_updated_cb; -}; - /* * The instance of CredentialManager is owned by {@code ServiceControllerImpl}. * Helping service controller to manage local credentials and coordinate with @@ -68,13 +58,14 @@ class CredentialManager { // Used to fetch private creds when broadcasting. virtual void GetPrivateCredentials( - location::nearby::api::CredentialSelector credential_selector, - location::nearby::api::GetPrivateCredentialsResultCallback callback) = 0; + CredentialSelector credential_selector, + GetPrivateCredentialsResultCallback callback) = 0; // Used to fetch remote public creds when scanning. virtual void GetPublicCredentials( - location::nearby::api::CredentialSelector credential_selector, - location::nearby::api::GetPublicCredentialsResultCallback callback) = 0; + CredentialSelector credential_selector, + PublicCredentialType public_credential_type, + GetPublicCredentialsResultCallback callback) = 0; // Decrypts the device metadata from a public credential. // Returns an empty string if decryption fails. diff --git a/presence/implementation/credential_manager_impl.cc b/presence/implementation/credential_manager_impl.cc index 636caef9..3256e9ef 100644 --- a/presence/implementation/credential_manager_impl.cc +++ b/presence/implementation/credential_manager_impl.cc @@ -32,9 +32,6 @@ namespace presence { namespace { using ::location::nearby::Base64Utils; using ::location::nearby::Crypto; -using ::location::nearby::api::CredentialOperationStatus; -using ::location::nearby::api::PublicCredentialType; -using ::location::nearby::api::SaveCredentialsResultCallback; using ::nearby::internal::DeviceMetadata; using ::nearby::internal::IdentityType; using ::nearby::internal::PrivateCredential; @@ -71,25 +68,11 @@ void CredentialManagerImpl::GenerateCredentials( } } - auto save_creds_lambda = [&public_credentials, &credentials_generated_cb]( - CredentialOperationStatus status) { - if (status == CredentialOperationStatus::kSucceeded) { - credentials_generated_cb.credentials_generated_cb(public_credentials); - } else { - NEARBY_LOGS(ERROR) << "Fails to save generated credentials"; - credentials_generated_cb.credentials_generated_cb( - std::vector()); - } - }; - - SaveCredentialsResultCallback save_creds_cb; - save_creds_cb.credentials_saved_cb = save_creds_lambda; - // Create credential_storage object and invoke SaveCredentials. credential_storage_ptr_->SaveCredentials( manager_app_id, device_metadata.account_name(), private_credentials, public_credentials, PublicCredentialType::kLocalPublicCredential, - save_creds_cb); + std::move(credentials_generated_cb)); } std::pair, std::unique_ptr> diff --git a/presence/implementation/credential_manager_impl.h b/presence/implementation/credential_manager_impl.h index c63aae9c..3e1cfd19 100644 --- a/presence/implementation/credential_manager_impl.h +++ b/presence/implementation/credential_manager_impl.h @@ -24,6 +24,7 @@ #include "absl/status/statusor.h" #include "absl/strings/string_view.h" #include "internal/platform/credential_storage_impl.h" +#include "internal/platform/implementation/credential_callbacks.h" #include "internal/proto/credential.pb.h" #include "presence/implementation/credential_manager.h" @@ -66,15 +67,14 @@ class CredentialManagerImpl : public CredentialManager { UpdateRemotePublicCredentialsCallback credentials_updated_cb) override{}; void GetPrivateCredentials( - location::nearby::api::CredentialSelector credential_selector, - location::nearby::api::GetPrivateCredentialsResultCallback callback) - override {} + CredentialSelector credential_selector, + GetPrivateCredentialsResultCallback callback) override{}; // Used to fetch remote public creds when scanning. void GetPublicCredentials( - location::nearby::api::CredentialSelector credential_selector, - location::nearby::api::GetPublicCredentialsResultCallback callback) - override {} + CredentialSelector credential_selector, + PublicCredentialType public_credential_type, + GetPublicCredentialsResultCallback callback) override{}; std::string DecryptDeviceMetadata( std::string device_metadata_encryption_key, std::string authenticity_key, diff --git a/presence/implementation/credential_manager_impl_test.cc b/presence/implementation/credential_manager_impl_test.cc index 43ebd359..0bc7ebe4 100644 --- a/presence/implementation/credential_manager_impl_test.cc +++ b/presence/implementation/credential_manager_impl_test.cc @@ -23,17 +23,16 @@ #include "protobuf-matchers/protocol-buffer-matchers.h" #include "gtest/gtest.h" #include "internal/platform/credential_storage_impl.h" -#include "internal/platform/implementation/credential_storage.h" #include "internal/platform/implementation/crypto.h" #include "internal/proto/credential.pb.h" +#include "internal/proto/credential.proto.h" namespace nearby { namespace presence { namespace { using ::location::nearby::Crypto; -using ::location::nearby::api::PublicCredentialType; -using ::location::nearby::api::SaveCredentialsResultCallback; using ::nearby::internal::DeviceMetadata; +using ::nearby::internal::IdentityType; using ::nearby::internal::PrivateCredential; using ::nearby::internal::PublicCredential; using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE; @@ -63,7 +62,7 @@ class CredentialManagerImplTest : public ::testing::Test { const std::vector<::nearby::internal::PublicCredential>& public_credentials, PublicCredentialType public_credential_type, - SaveCredentialsResultCallback callback), + GenerateCredentialsCallback callback), (override)); }; @@ -75,7 +74,6 @@ class CredentialManagerImplTest : public ::testing::Test { std::unique_ptr mock_credential_storage_ptr_; }; -// TODO(b/241926454): Make sure CredentialManager builds with Github. TEST(CredentialManagerImpl, CreateOneCredentialSuccessfully) { DeviceMetadata device_metadata = CreateTestDeviceMetadata(); @@ -141,7 +139,7 @@ TEST(CredentialManagerImpl, GenerateCredentialsSuccessfully) { credentials_generated_cb.credentials_generated_cb = create_creds_callback_lambda; - std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; + std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; credential_manager.GenerateCredentials( device_metadata, @@ -171,23 +169,19 @@ TEST(CredentialManagerImpl, GenerateCredentialsSuccessfullyButStoreFailed) { const std::vector& private_credentials, const std::vector& public_credentials, PublicCredentialType public_credential_type, - SaveCredentialsResultCallback callback) { - callback.credentials_saved_cb( - location::nearby::api::CredentialOperationStatus::kFailed); + GenerateCredentialsCallback callback) { + // Do nothing! Testing failed SaveCredentials call. })); CredentialManagerImpl credential_manager(std::move(credential_storage_ptr)); GenerateCredentialsCallback credentials_generated_cb; std::vector publicCredentials; - auto create_creds_callback_lambda = + credentials_generated_cb.credentials_generated_cb = [&publicCredentials]( std::vector credentials) { publicCredentials = credentials; }; - - credentials_generated_cb.credentials_generated_cb = - create_creds_callback_lambda; - std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; + std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; credential_manager.GenerateCredentials( device_metadata,