1 /* 2 * Copyright (C) 2016 The Android Open Source Project 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 #ifndef ANDROID_HARDWARE_ISERVICE_MANAGER_H 18 #define ANDROID_HARDWARE_ISERVICE_MANAGER_H 19 20 #include <string> 21 #include <vector> 22 23 #include <android/hidl/base/1.0/IBase.h> 24 #include <utils/StrongPointer.h> 25 26 namespace android { 27 28 namespace hidl { 29 namespace manager { 30 namespace V1_0 { 31 struct IServiceManager; 32 } // namespace V1_0 33 namespace V1_1 { 34 struct IServiceManager; 35 } // namespace V1_1 36 namespace V1_2 { 37 struct IServiceManager; 38 } // namespace V1_2 39 } // namespace manager 40 } // namespace hidl 41 42 namespace hardware { 43 44 namespace details { 45 46 // Will not attempt to start a lazy HAL 47 // e.x.: [email protected]::IFoo, default 48 void waitForHwService(const std::string &interface, const std::string &instanceName); 49 50 void preloadPassthroughService(const std::string &descriptor); 51 52 // Returns a service with the following constraints: 53 // - retry => service is waited for and returned if available in this process 54 // - getStub => internal only. Forces to get the unwrapped (no BsFoo) if available. 55 // TODO(b/65843592) 56 // If the service is a remote service, this function returns BpBase. If the service is 57 // a passthrough service, this function returns the appropriately wrapped Bs child object. 58 sp<::android::hidl::base::V1_0::IBase> getRawServiceInternal(const std::string& descriptor, 59 const std::string& instance, 60 bool retry, bool getStub); 61 62 status_t registerAsServiceInternal(const sp<::android::hidl::base::V1_0::IBase>& service, 63 const std::string& name); 64 } // namespace details 65 66 // These functions are for internal use by hidl. If you want to get ahold 67 // of an interface, the best way to do this is by calling IFoo::getService() 68 sp<::android::hidl::manager::V1_0::IServiceManager> defaultServiceManager(); 69 sp<::android::hidl::manager::V1_1::IServiceManager> defaultServiceManager1_1(); 70 sp<::android::hidl::manager::V1_2::IServiceManager> defaultServiceManager1_2(); 71 sp<::android::hidl::manager::V1_0::IServiceManager> getPassthroughServiceManager(); 72 sp<::android::hidl::manager::V1_1::IServiceManager> getPassthroughServiceManager1_1(); 73 74 /** 75 * Given a descriptor (e.g. from IFoo::descriptor), return a list of all instance names 76 * on a device (e.g. the VINTF manifest). These HALs may not be currently running, but 77 * the expectation is that if they aren't running, they should start as lazy HALs. 78 * So, getService should return for each of these instance names. 79 */ 80 std::vector<std::string> getAllHalInstanceNames(const std::string& descriptor); 81 82 /** 83 * Given a service that is in passthrough mode, this function will go ahead and load the 84 * required passthrough module library (but not call HIDL_FETCH_I* functions to instantiate it). 85 * 86 * E.x.: preloadPassthroughService<IFoo>(); 87 */ 88 template<typename I> 89 static inline void preloadPassthroughService() { 90 details::preloadPassthroughService(I::descriptor); 91 } 92 93 } // namespace hardware 94 } // namespace android 95 96 #endif // ANDROID_HARDWARE_ISERVICE_MANAGER_H 97 98