quick_pair_process.cc 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/services/quick_pair/quick_pair_process_manager.h"
  5. #include "ash/quick_pair/common/logging.h"
  6. #include "ash/services/quick_pair/public/cpp/decrypted_passkey.h"
  7. #include "ash/services/quick_pair/public/cpp/decrypted_response.h"
  8. #include "ash/services/quick_pair/public/cpp/not_discoverable_advertisement.h"
  9. #include "ash/services/quick_pair/public/mojom/fast_pair_data_parser.mojom.h"
  10. #include "ash/services/quick_pair/quick_pair_process.h"
  11. #include "base/bind.h"
  12. #include "base/callback.h"
  13. #include "base/callback_helpers.h"
  14. namespace ash {
  15. namespace quick_pair {
  16. namespace quick_pair_process {
  17. namespace {
  18. QuickPairProcessManager* g_process_manager = nullptr;
  19. std::unique_ptr<QuickPairProcessManager::ProcessReference> GetProcessReference(
  20. ProcessStoppedCallback process_stopped_callback) {
  21. if (!g_process_manager) {
  22. QP_LOG(ERROR) << "QuickPairProcess::SetProcessManager() must be called "
  23. "before any QuickPairProcess use.";
  24. return nullptr;
  25. }
  26. return g_process_manager->GetProcessReference(
  27. std::move(process_stopped_callback));
  28. }
  29. } // namespace
  30. void SetProcessManager(QuickPairProcessManager* process_manager) {
  31. g_process_manager = process_manager;
  32. }
  33. void GetHexModelIdFromServiceData(
  34. const std::vector<uint8_t>& service_data,
  35. GetHexModelIdFromServiceDataCallback callback,
  36. ProcessStoppedCallback process_stopped_callback) {
  37. std::unique_ptr<QuickPairProcessManager::ProcessReference> process_reference =
  38. GetProcessReference(std::move(process_stopped_callback));
  39. if (!process_reference) {
  40. QP_LOG(WARNING) << __func__ << ": Failed to get new process reference.";
  41. std::move(callback).Run(absl::nullopt);
  42. return;
  43. }
  44. auto* raw_process_reference = process_reference.get();
  45. raw_process_reference->GetFastPairDataParser()->GetHexModelIdFromServiceData(
  46. service_data,
  47. base::BindOnce(
  48. [](std::unique_ptr<QuickPairProcessManager::ProcessReference>,
  49. GetHexModelIdFromServiceDataCallback callback,
  50. const absl::optional<std::string>& result) {
  51. std::move(callback).Run(result);
  52. },
  53. std::move(process_reference), std::move(callback)));
  54. }
  55. void ParseDecryptedResponse(
  56. const std::vector<uint8_t>& aes_key,
  57. const std::vector<uint8_t>& encrypted_response_bytes,
  58. ParseDecryptedResponseCallback callback,
  59. ProcessStoppedCallback process_stopped_callback) {
  60. std::unique_ptr<QuickPairProcessManager::ProcessReference> process_reference =
  61. GetProcessReference(std::move(process_stopped_callback));
  62. if (!process_reference) {
  63. QP_LOG(WARNING) << __func__ << ": Failed to get new process reference.";
  64. std::move(callback).Run(absl::nullopt);
  65. return;
  66. }
  67. auto* raw_process_reference = process_reference.get();
  68. raw_process_reference->GetFastPairDataParser()->ParseDecryptedResponse(
  69. aes_key, encrypted_response_bytes,
  70. base::BindOnce(
  71. [](std::unique_ptr<QuickPairProcessManager::ProcessReference>,
  72. ParseDecryptedResponseCallback callback,
  73. const absl::optional<DecryptedResponse>& result) {
  74. std::move(callback).Run(result);
  75. },
  76. std::move(process_reference), std::move(callback)));
  77. }
  78. void ParseDecryptedPasskey(const std::vector<uint8_t>& aes_key,
  79. const std::vector<uint8_t>& encrypted_passkey_bytes,
  80. ParseDecryptedPasskeyCallback callback,
  81. ProcessStoppedCallback process_stopped_callback) {
  82. std::unique_ptr<QuickPairProcessManager::ProcessReference> process_reference =
  83. GetProcessReference(std::move(process_stopped_callback));
  84. if (!process_reference) {
  85. QP_LOG(WARNING) << __func__ << ": Failed to get new process reference.";
  86. std::move(callback).Run(absl::nullopt);
  87. return;
  88. }
  89. auto* raw_process_reference = process_reference.get();
  90. raw_process_reference->GetFastPairDataParser()->ParseDecryptedPasskey(
  91. aes_key, encrypted_passkey_bytes,
  92. base::BindOnce(
  93. [](std::unique_ptr<QuickPairProcessManager::ProcessReference>,
  94. ParseDecryptedPasskeyCallback callback,
  95. const absl::optional<DecryptedPasskey>& result) {
  96. std::move(callback).Run(result);
  97. },
  98. std::move(process_reference), std::move(callback)));
  99. }
  100. void ParseNotDiscoverableAdvertisement(
  101. const std::vector<uint8_t>& service_data,
  102. const std::string& address,
  103. ParseNotDiscoverableAdvertisementCallback callback,
  104. ProcessStoppedCallback process_stopped_callback) {
  105. std::unique_ptr<QuickPairProcessManager::ProcessReference> process_reference =
  106. GetProcessReference(std::move(process_stopped_callback));
  107. if (!process_reference) {
  108. QP_LOG(WARNING) << __func__ << ": Failed to get new process reference.";
  109. std::move(callback).Run(absl::nullopt);
  110. return;
  111. }
  112. auto* raw_process_reference = process_reference.get();
  113. raw_process_reference->GetFastPairDataParser()
  114. ->ParseNotDiscoverableAdvertisement(
  115. service_data, address,
  116. base::BindOnce(
  117. [](std::unique_ptr<QuickPairProcessManager::ProcessReference>,
  118. ParseNotDiscoverableAdvertisementCallback callback,
  119. const absl::optional<NotDiscoverableAdvertisement>& result) {
  120. std::move(callback).Run(result);
  121. },
  122. std::move(process_reference), std::move(callback)));
  123. }
  124. void ParseMessageStreamMessages(
  125. const std::vector<uint8_t>& message_bytes,
  126. ParseMessageStreamMessagesCallback callback,
  127. ProcessStoppedCallback process_stopped_callback) {
  128. std::unique_ptr<QuickPairProcessManager::ProcessReference> process_reference =
  129. GetProcessReference(std::move(process_stopped_callback));
  130. if (!process_reference) {
  131. QP_LOG(WARNING) << __func__ << ": Failed to get new process reference.";
  132. std::move(callback).Run({});
  133. return;
  134. }
  135. auto* raw_process_reference = process_reference.get();
  136. raw_process_reference->GetFastPairDataParser()->ParseMessageStreamMessages(
  137. message_bytes,
  138. base::BindOnce(
  139. [](std::unique_ptr<QuickPairProcessManager::ProcessReference>,
  140. ParseMessageStreamMessagesCallback callback,
  141. std::vector<mojom::MessageStreamMessagePtr> result) {
  142. std::move(callback).Run(std::move(result));
  143. },
  144. std::move(process_reference), std::move(callback)));
  145. }
  146. } // namespace quick_pair_process
  147. } // namespace quick_pair
  148. } // namespace ash