Release v4.0.0 of Boston Dynamics Spot SDK

Author: bd-sdk-publisher

README.md

@@ -19,7 +19,7 @@ The official Spot SDK documentation also contains information relevant to the C+
 *  [Payload developer documentation](https://dev.bostondynamics.com/docs/payload/readme). Payloads add additional sensing, communication, and control capabilities beyond what the base platform provides. The Payload ICD covers the mechanical, electrical, and software interfaces that Spot supports.
 *  [Spot API protocol definition](https://dev.bostondynamics.com/docs/protos/readme). This reference guide covers the details of the protocol applications used to communicate to Spot. Application developers who wish to use a language other than Python can implement clients that speak the protocol.
 
-This is version 3.3.2 of the C++ SDK. Please review the [Release Notes](docs/cpp_release_notes.md) to see what has changed.
+This is version 4.0.0 of the C++ SDK. Please review the [Release Notes](docs/cpp_release_notes.md) to see what has changed.
 
 ## Contents
 

choreography_protos/README.md

@@ -12,4 +12,4 @@ Development Kit License (20191101-BDSDK-SL).
 <img src="https://www.bostondynamics.com/sites/default/files/2020-05/spot.png" style="max-width:50%;">
 </p>
 
-The bosdyn-choreography-protos wheel contains the Protobuf definitions in the Boston Dynamics Choreography API. The message and service types defined in this wheel are used by the clients in [bosdyn-choreography-client](https://pypi.org/project/bosdyn-choreography-client/) wheel to communicate with the services running on the Spot robots.
+The bosdyn-choreography-protos wheel has been deprecated. The Python implementation for the Protobuf definitions previously stored in this build has been integrated with the [bosdyn-api wheel](https://pypi.org/project/bosdyn-api/).

choreography_protos/bosdyn/api/README.md

@@ -162,6 +162,40 @@ void DataAcquisitionClient::OnCancelAcquisitionComplete(
     promise.set_value({ret_status, std::move(response)});
 }
 
+// RPC to request live data for each capability
+std::shared_future<DataAcquisitionLiveDataResultType> DataAcquisitionClient::GetLiveDataAsync(
+    ::bosdyn::api::LiveDataRequest& request, const RPCParameters& parameters) {
+    std::promise<DataAcquisitionLiveDataResultType> response;
+    std::shared_future<DataAcquisitionLiveDataResultType> future = response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time =
+        InitiateAsyncCall<::bosdyn::api::LiveDataRequest, ::bosdyn::api::LiveDataResponse,
+                          ::bosdyn::api::LiveDataResponse>(
+            request,
+            std::bind(&::bosdyn::api::DataAcquisitionService::Stub::AsyncGetLiveData, m_stub.get(), _1, _2,
+                      _3),
+            std::bind(&DataAcquisitionClient::OnLiveDataComplete, this, _1, _2, _3, _4, _5),
+            std::move(response), parameters);
+
+    return future;
+}
+
+DataAcquisitionLiveDataResultType DataAcquisitionClient::GetLiveData(
+    ::bosdyn::api::LiveDataRequest& request, const RPCParameters& parameters) {
+    return GetLiveDataAsync(request, parameters).get();
+}
+
+void DataAcquisitionClient::OnLiveDataComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::LiveDataRequest& request,
+    ::bosdyn::api::LiveDataResponse&& response, const grpc::Status& status,
+    std::promise<DataAcquisitionLiveDataResultType> promise) {
+    ::bosdyn::common::Status ret_status = ProcessResponseAndGetFinalStatus<::bosdyn::api::LiveDataResponse>(
+        status, response, SDKErrorCode::Success);
+
+    promise.set_value({ret_status, std::move(response)});
+}
+
 // Start of ServiceClient overrides.
 ServiceClient::QualityOfService DataAcquisitionClient::GetQualityOfService() const {
     return QualityOfService::NORMAL;

cpp/CMakeLists.txt

@@ -22,6 +22,7 @@ typedef Result<::bosdyn::api::AcquireDataResponse> DataAcquisitionAcquireDataRes
 typedef Result<::bosdyn::api::GetStatusResponse> DataAcquisitionGetStatusResultType;
 typedef Result<::bosdyn::api::GetServiceInfoResponse> DataAcquisitionServiceInfoResultType;
 typedef Result<::bosdyn::api::CancelAcquisitionResponse> DataAcquisitionCancelAcquisitionResultType;
+typedef Result<::bosdyn::api::LiveDataResponse> DataAcquisitionLiveDataResultType;
 
 class DataAcquisitionClient : public ServiceClient {
  public:
@@ -61,6 +62,14 @@ class DataAcquisitionClient : public ServiceClient {
     DataAcquisitionCancelAcquisitionResultType CancelAcquisition(
         ::bosdyn::api::CancelAcquisitionRequest& request, const RPCParameters& parameters = RPCParameters());
 
+    // Asynchronous RPC to request live data for each capability.
+    std::shared_future<DataAcquisitionLiveDataResultType> GetLiveDataAsync(
+        ::bosdyn::api::LiveDataRequest& request, const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous RPC to request live data for each capability.
+    DataAcquisitionLiveDataResultType GetLiveData(
+        ::bosdyn::api::LiveDataRequest& request, const RPCParameters& parameters = RPCParameters());
+
     // Start of ServiceClient overrides.
     QualityOfService GetQualityOfService() const override;
     void SetComms(const std::shared_ptr<grpc::ChannelInterface>& channel) override;
@@ -95,6 +104,11 @@ class DataAcquisitionClient : public ServiceClient {
         ::bosdyn::api::CancelAcquisitionResponse&& response, const grpc::Status& status,
         std::promise<DataAcquisitionCancelAcquisitionResultType> promise);
 
+    // Callback function registered for the asynchronous calls to get live data.
+    void OnLiveDataComplete(MessagePumpCallBase* call, const ::bosdyn::api::LiveDataRequest& request,
+        ::bosdyn::api::LiveDataResponse&& response, const grpc::Status& status,
+        std::promise<DataAcquisitionLiveDataResultType> promise);
+
     std::unique_ptr<::bosdyn::api::DataAcquisitionService::Stub> m_stub;
 
     // Default service name for the Data Acquisition service.

cpp/bosdyn/client/data_acquisition/data_acquisition_client.cpp

@@ -358,6 +358,91 @@ void DataAcquisitionStoreClient::OnStoreAlertDataComplete(
     promise.set_value({ret_status, std::move(response)});
 }
 
+std::shared_future<DataAcquisitionStoreQueryStoredCapturesResultType>
+DataAcquisitionStoreClient::QueryStoredCapturesAsync(
+    ::bosdyn::api::QueryStoredCapturesRequest& request, const RPCParameters& parameters) {
+    std::promise<DataAcquisitionStoreQueryStoredCapturesResultType> response;
+    std::shared_future<DataAcquisitionStoreQueryStoredCapturesResultType> future =
+        response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time =
+        InitiateResponseStreamAsyncCall<::bosdyn::api::QueryStoredCapturesRequest,
+                                        ::bosdyn::api::DataChunk,
+                                        ::bosdyn::api::QueryStoredCapturesResponse>(
+            request,
+            std::bind(&::bosdyn::api::DataAcquisitionStoreService::Stub::AsyncQueryStoredCaptures,
+                      m_stub.get(), _1, _2, _3, _4),
+            std::bind(&DataAcquisitionStoreClient::OnQueryStoredCapturesComplete, this, _1, _2, _3,
+                      _4, _5),
+            std::move(response), parameters);
+
+    return future;
+}
+
+DataAcquisitionStoreQueryStoredCapturesResultType DataAcquisitionStoreClient::QueryStoredCaptures(
+    ::bosdyn::api::QueryStoredCapturesRequest& request, const RPCParameters& parameters) {
+    return QueryStoredCapturesAsync(request, parameters).get();
+}
+
+void DataAcquisitionStoreClient::OnQueryStoredCapturesComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::QueryStoredCapturesRequest& request,
+    std::vector<::bosdyn::api::DataChunk>&& responses, const grpc::Status& status,
+    std::promise<DataAcquisitionStoreQueryStoredCapturesResultType> promise) {
+    std::vector<const ::bosdyn::api::DataChunk*> chunks;
+    for (auto& chunk : responses) {
+        chunks.push_back(&chunk);
+    }
+
+    auto response_result =
+        MessageFromDataChunks<::bosdyn::api::QueryStoredCapturesResponse>(chunks);
+    if (!response_result) {
+        promise.set_value(response_result);
+        return;
+    }
+
+    ::bosdyn::api::QueryStoredCapturesResponse&& response = response_result.move();
+    auto ret_status = ProcessResponseAndGetFinalStatus<::bosdyn::api::QueryStoredCapturesResponse>(
+        status, response, SDKErrorCode::Success);
+    promise.set_value({ret_status, std::move(response)});
+}
+
+std::shared_future<DataAcquisitionStoreQueryMaxCaptureIdResultType>
+DataAcquisitionStoreClient::QueryMaxCaptureIdAsync(const RPCParameters& parameters) {
+    ::bosdyn::api::QueryMaxCaptureIdRequest request;
+    std::promise<DataAcquisitionStoreQueryMaxCaptureIdResultType> response;
+    std::shared_future<DataAcquisitionStoreQueryMaxCaptureIdResultType> future =
+        response.get_future();
+    BOSDYN_ASSERT_PRECONDITION(m_stub != nullptr, "Stub for service is unset!");
+
+    MessagePumpCallBase* one_time = InitiateAsyncCall<::bosdyn::api::QueryMaxCaptureIdRequest,
+                                                      ::bosdyn::api::QueryMaxCaptureIdResponse,
+                                                      ::bosdyn::api::QueryMaxCaptureIdResponse>(
+        request,
+        std::bind(&::bosdyn::api::DataAcquisitionStoreService::Stub::AsyncQueryMaxCaptureId,
+                  m_stub.get(), _1, _2, _3),
+        std::bind(&DataAcquisitionStoreClient::OnQueryMaxCaptureIdComplete, this, _1, _2, _3, _4,
+                  _5),
+        std::move(response), parameters);
+
+    return future;
+}
+
+DataAcquisitionStoreQueryMaxCaptureIdResultType DataAcquisitionStoreClient::QueryMaxCaptureId(
+    const RPCParameters& parameters) {
+    return QueryMaxCaptureIdAsync(parameters).get();
+}
+
+void DataAcquisitionStoreClient::OnQueryMaxCaptureIdComplete(
+    MessagePumpCallBase* call, const ::bosdyn::api::QueryMaxCaptureIdRequest& request,
+    ::bosdyn::api::QueryMaxCaptureIdResponse&& response, const grpc::Status& status,
+    std::promise<DataAcquisitionStoreQueryMaxCaptureIdResultType> promise) {
+    ::bosdyn::common::Status ret_status =
+        ProcessResponseAndGetFinalStatus<::bosdyn::api::QueryMaxCaptureIdResponse>(
+            status, response, SDKErrorCode::Success);
+
+    promise.set_value({ret_status, std::move(response)});
+}
 
 // Start of ServiceClient overrides.
 ServiceClient::QualityOfService DataAcquisitionStoreClient::GetQualityOfService() const {

cpp/bosdyn/client/data_acquisition/data_acquisition_client.h

@@ -30,6 +30,10 @@ typedef Result<::bosdyn::api::StoreMetadataResponse> DataAcquisitionStoreStoreMe
 typedef Result<::bosdyn::api::ListStoredAlertDataResponse>
     DataAcquisitionStoreListStoredAlertDataResultType;
 typedef Result<::bosdyn::api::StoreAlertDataResponse> DataAcquisitionStoreStoreAlertDataResultType;
+typedef Result<::bosdyn::api::QueryStoredCapturesResponse>
+    DataAcquisitionStoreQueryStoredCapturesResultType;
+typedef Result<::bosdyn::api::QueryMaxCaptureIdResponse>
+    DataAcquisitionStoreQueryMaxCaptureIdResultType;
 
 class DataAcquisitionStoreClient : public ServiceClient {
  public:
@@ -127,6 +131,23 @@ class DataAcquisitionStoreClient : public ServiceClient {
         ::bosdyn::api::StoreAlertDataRequest& request,
         const RPCParameters& parameters = RPCParameters());
 
+    // Asynchronous RPC to trigger data acquisition store to query stored captures.
+    std::shared_future<DataAcquisitionStoreQueryStoredCapturesResultType> QueryStoredCapturesAsync(
+        ::bosdyn::api::QueryStoredCapturesRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous RPC to trigger data acquisition store to query stored captures.
+    DataAcquisitionStoreQueryStoredCapturesResultType QueryStoredCaptures(
+        ::bosdyn::api::QueryStoredCapturesRequest& request,
+        const RPCParameters& parameters = RPCParameters());
+
+    // Asynchronous RPC to get the maximum stored capture_id.
+    std::shared_future<DataAcquisitionStoreQueryMaxCaptureIdResultType> QueryMaxCaptureIdAsync(
+        const RPCParameters& parameters = RPCParameters());
+
+    // Synchronous RPC to get the maximum stored capture_id.
+    DataAcquisitionStoreQueryMaxCaptureIdResultType QueryMaxCaptureId(
+        const RPCParameters& parameters = RPCParameters());
 
     // Start of ServiceClient overrides.
     QualityOfService GetQualityOfService() const override;
@@ -197,6 +218,15 @@ class DataAcquisitionStoreClient : public ServiceClient {
         ::bosdyn::api::StoreAlertDataResponse&& response, const grpc::Status& status,
         std::promise<DataAcquisitionStoreStoreAlertDataResultType> promise);
 
+    void OnQueryStoredCapturesComplete(
+        MessagePumpCallBase* call, const ::bosdyn::api::QueryStoredCapturesRequest& request,
+        std::vector<::bosdyn::api::DataChunk>&& responses, const grpc::Status& status,
+        std::promise<DataAcquisitionStoreQueryStoredCapturesResultType> promise);
+
+    void OnQueryMaxCaptureIdComplete(
+        MessagePumpCallBase* call, const ::bosdyn::api::QueryMaxCaptureIdRequest& request,
+        ::bosdyn::api::QueryMaxCaptureIdResponse&& response, const grpc::Status& status,
+        std::promise<DataAcquisitionStoreQueryMaxCaptureIdResultType> promise);
 
     std::unique_ptr<::bosdyn::api::DataAcquisitionStoreService::Stub> m_stub;
 

cpp/bosdyn/client/data_acquisition_store/data_acquisition_store_client.cpp

@@ -19,3 +19,6 @@ DEFINE_PROTO_ENUM_ERRORCODE_IMPL_GRAPHNAV(NavigateToAnchorResponse_Status, valco
 // NOTE: NavigationFeedbackResponse is not converted to std::error_code on purpose.
 DEFINE_PROTO_ENUM_ERRORCODE_IMPL_GRAPHNAV(DownloadWaypointSnapshotResponse_Status, valcode == 1)
 DEFINE_PROTO_ENUM_ERRORCODE_IMPL_GRAPHNAV(DownloadEdgeSnapshotResponse_Status, valcode == 1)
+DEFINE_PROTO_ENUM_ERRORCODE_IMPL_GRAPHNAV(UploadWaypointSnapshotResponse_Status, valcode == 1)
+DEFINE_PROTO_ENUM_ERRORCODE_IMPL_GRAPHNAV(UploadGraphResponse_Status, valcode == 1)
+

cpp/bosdyn/client/data_acquisition_store/data_acquisition_store_client.h

@@ -196,28 +196,43 @@ bool Lease::IsValid() const {
     return !m_lease_proto.resource().empty() && m_lease_proto.sequence_size() > 0;
 }
 
-void Lease::UpdateFromLeaseUseResult(const ::bosdyn::api::LeaseUseResult& lease_use_result) {
+bool Lease::UpdateFromLeaseUseResult(const ::bosdyn::api::LeaseUseResult& lease_use_result) {
     if (lease_use_result.status() == ::bosdyn::api::LeaseUseResult::STATUS_OLDER) {
-        // The lease from the lease wallet was an older lease.
-        if (Compare(Lease(lease_use_result.attempted_lease())) == CompareResult::SAME) {
-            // If the lease use result's lease matches this current lease, then mark it as other
-            // owner since it was found to be an older lease and we never incremented it.
-            m_lease_status = LeaseStatus::OTHER_OWNER;
+        // The lease was reported as being too old. Check if that applies to our current lease.
+        Lease latest_known_lease(lease_use_result.latest_known_lease());
+        if (latest_known_lease.IsValid()) {
+            const auto cmp = Compare(latest_known_lease);
+            if (cmp == Lease::CompareResult::NEWER || cmp == Lease::CompareResult::SAME) {
+                // The attempted lease was older, but the lease in the wallet has been updated in
+                // the meantime to something that is newer than what the robot has seen, so this
+                // OLDER result is no longer relevant.
+                return false;
+            }
         }
+        // The lease from the lease wallet was an older lease.
+        m_lease_status = LeaseStatus::OTHER_OWNER;
+        return true;
     } else if (lease_use_result.status() == ::bosdyn::api::LeaseUseResult::STATUS_WRONG_EPOCH) {
-        // The lease from the lease wallet is the wrong epoch.
-        if (Compare(Lease(lease_use_result.attempted_lease())) == CompareResult::SAME) {
+        // The lease is reported as having the wrong epoch.
+        // Check if that applies to our current lease.
+        if (m_lease_proto.epoch() != lease_use_result.latest_known_lease().epoch()) {
             // If the lease use result's lease matches this current lease, then mark it as unowned
             // because it is now entirely wrong (different epochs) for the resource.
             m_lease_status = LeaseStatus::UNOWNED;
+            return true;
         }
+        return false;
     } else if (lease_use_result.status() == ::bosdyn::api::LeaseUseResult::STATUS_REVOKED) {
-        // The lease from the lease wallet is the wrong epoch.
-        if (Compare(Lease(lease_use_result.attempted_lease())) == CompareResult::SAME) {
+        // The lease was reported as revoked. Check if that applies to our current lease.
+        auto comparison = Compare(Lease(lease_use_result.attempted_lease()));
+        if (comparison == CompareResult::SAME || comparison == CompareResult::SUB_LEASE) {
             // If the lease use result's lease matches this current lease, then mark it as revoked.
             m_lease_status = LeaseStatus::REVOKED;
+            return true;
         }
+        return false;
     }
+    return true;
 }
 
 Lease Lease::SplitLease(const std::string& resource, const ResourceHierarchy& hierarchy) const {
@@ -230,9 +245,7 @@ Lease Lease::SplitLease(const std::string& resource, const ResourceHierarchy& hi
     }
 
     Lease result(*this);
-    const auto& sub_hierarchy = hierarchy.GetHierarchy(resource);
-    const auto& resource_tree = sub_hierarchy.ResourceTree();
-    result.m_lease_proto.set_resource(resource_tree.resource());
+    result.m_lease_proto.set_resource(resource);
     return result;
 }