1 // 2 // Copyright (C) 2015 Google, Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at: 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "service/ipc/binder/interface_with_instances_base.h" 18 19 #include <base/logging.h> 20 21 namespace ipc { 22 namespace binder { 23 24 bool InterfaceWithInstancesBase::RegisterInstanceBase( 25 const android::sp<IInterface>& callback, 26 bluetooth::BluetoothInstanceFactory* factory) { 27 VLOG(2) << __func__; 28 CHECK(factory); 29 30 if (!callback.get()) { 31 LOG(ERROR) << "Cannot register a NULL callback"; 32 return false; 33 } 34 35 // Store the callback in the pending list. It will get removed later when the 36 // stack notifies us asynchronously. 37 bluetooth::UUID app_uuid = bluetooth::UUID::GetRandom(); 38 if (!pending_callbacks_.Register(app_uuid, callback)) { 39 LOG(ERROR) << "Failed to store |callback| to map"; 40 return false; 41 } 42 43 // Create a weak pointer and pass that to the callback to prevent an invalid 44 // access later. Since this object is managed using Android's StrongPointer 45 // (sp) we are using a wp here rather than std::weak_ptr. 46 android::wp<InterfaceWithInstancesBase> weak_ptr_to_this(this); 47 48 bluetooth::BluetoothInstanceFactory::RegisterCallback cb = 49 [weak_ptr_to_this]( 50 bluetooth::BLEStatus status, 51 const bluetooth::UUID& in_uuid, 52 std::unique_ptr<bluetooth::BluetoothInstance> instance) { 53 // If the weak pointer was invalidated then there is nothing we can do. 54 android::sp<InterfaceWithInstancesBase> strong_ptr_to_this = 55 weak_ptr_to_this.promote(); 56 if (!strong_ptr_to_this.get()) { 57 VLOG(2) << "InterfaceWithInstancesBase was deleted while instance was" 58 << " being registered"; 59 return; 60 } 61 62 strong_ptr_to_this->OnRegisterInstance( 63 status, in_uuid, std::move(instance)); 64 }; 65 66 if (factory->RegisterInstance(app_uuid, cb)) 67 return true; 68 69 LOG(ERROR) << "Failed to register instance"; 70 pending_callbacks_.Remove(app_uuid); 71 72 return false; 73 } 74 75 void InterfaceWithInstancesBase::UnregisterInstanceBase(int instance_id) { 76 VLOG(2) << __func__; 77 std::lock_guard<std::mutex> lock(maps_lock_); 78 79 id_to_cb_.Remove(instance_id); 80 id_to_instance_.erase(instance_id); 81 } 82 83 void InterfaceWithInstancesBase::UnregisterAllBase() { 84 VLOG(2) << __func__; 85 std::lock_guard<std::mutex> lock(maps_lock_); 86 87 id_to_cb_.Clear(); 88 id_to_instance_.clear(); 89 } 90 91 android::sp<IInterface> InterfaceWithInstancesBase::GetCallback( 92 int instance_id) { 93 return id_to_cb_.Get(instance_id); 94 } 95 96 std::shared_ptr<bluetooth::BluetoothInstance> 97 InterfaceWithInstancesBase::GetInstance(int instance_id) { 98 auto iter = id_to_instance_.find(instance_id); 99 if (iter == id_to_instance_.end()) 100 return std::shared_ptr<bluetooth::BluetoothInstance>(); 101 return iter->second; 102 } 103 104 void InterfaceWithInstancesBase::OnRegisterInstance( 105 bluetooth::BLEStatus status, 106 const bluetooth::UUID& uuid, 107 std::unique_ptr<bluetooth::BluetoothInstance> instance) { 108 VLOG(2) << __func__ << " - status: " << status; 109 110 // Simply remove the callback from |pending_callbacks_| as it no longer 111 // belongs in there. 112 sp<IInterface> callback = pending_callbacks_.Remove(uuid); 113 114 // |callback| might be NULL if it was removed from the pending list, e.g. the 115 // remote process that owns the callback died. 116 if (!callback.get()) { 117 VLOG(1) << "Callback was removed before the call to \"RegisterInstance\" " 118 << "returned; unregistering instance"; 119 return; 120 } 121 122 if (status != bluetooth::BLE_STATUS_SUCCESS) { 123 // The call wasn't successful. Notify the implementation and return. 124 LOG(ERROR) << "Failed to register instance: " << status; 125 OnRegisterInstanceImpl(status, callback, nullptr); 126 return; 127 } 128 129 std::lock_guard<std::mutex> lock(maps_lock_); 130 int instance_id = instance->GetInstanceId(); 131 CHECK(instance_id); 132 if (!id_to_cb_.Register(instance_id, callback, this)) { 133 LOG(ERROR) << "Failed to store callback"; 134 OnRegisterInstanceImpl(bluetooth::BLE_STATUS_FAILURE, callback, nullptr); 135 return; 136 } 137 138 VLOG(1) << "Registered BluetoothInstance - ID: " << instance_id; 139 140 auto shared_instance = 141 std::shared_ptr<bluetooth::BluetoothInstance>(instance.release()); 142 id_to_instance_[instance_id] = shared_instance; 143 144 OnRegisterInstanceImpl(status, callback, shared_instance.get()); 145 } 146 147 void InterfaceWithInstancesBase::OnRemoteCallbackRemoved(const int& key) { 148 VLOG(2) << __func__ << " instance_id: " << key; 149 std::lock_guard<std::mutex> lock(maps_lock_); 150 151 // No need to remove from the callback map as the entry should be already 152 // removed when this callback gets called. 153 id_to_instance_.erase(key); 154 } 155 156 } // namespace binder 157 } // namespace ipc 158
