1 /*
2  * Copyright (C) 2015 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 SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
18 #define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
19 
20 #include <map>
21 #include <string>
22 #include <vector>
23 
24 #include <base/macros.h>
25 #include <binder/Binder.h>
26 #include <binder/IBinder.h>
27 #include <binderwrapper/binder_wrapper.h>
28 
29 namespace android {
30 
31 // Stub implementation of BinderWrapper for testing.
32 //
33 // Example usage:
34 //
35 // First, assuming a base IFoo binder interface, create a stub class that
36 // derives from BnFoo to implement the receiver side of the communication:
37 //
38 //   class StubFoo : public BnFoo {
39 //    public:
40 //     ...
41 //     status_t doSomething(int arg) override {
42 //       // e.g. save passed-in value for later inspection by tests.
43 //       return OK;
44 //     }
45 //   };
46 //
47 // Next, from your test code, inject a StubBinderManager either directly or by
48 // inheriting from the BinderTestBase class:
49 //
50 //   StubBinderWrapper* wrapper = new StubBinderWrapper();
51 //   BinderWrapper::InitForTesting(wrapper);  // Takes ownership.
52 //
53 // Also from your test, create a StubFoo and register it with the wrapper:
54 //
55 //   StubFoo* foo = new StubFoo();
56 //   sp<IBinder> binder(foo);
57 //   wrapper->SetBinderForService("foo", binder);
58 //
59 // The code being tested can now use the wrapper to get the stub and call it:
60 //
61 //   sp<IBinder> binder = BinderWrapper::Get()->GetService("foo");
62 //   CHECK(binder.get());
63 //   sp<IFoo> foo = interface_cast<IFoo>(binder);
64 //   CHECK_EQ(foo->doSomething(3), OK);
65 //
66 // To create a local BBinder object, production code can call
67 // CreateLocalBinder(). Then, a test can get the BBinder's address via
68 // local_binders() to check that they're passed as expected in binder calls.
69 //
70 class StubBinderWrapper : public BinderWrapper {
71  public:
72   StubBinderWrapper();
73   ~StubBinderWrapper() override;
74 
local_binders()75   const std::vector<sp<BBinder>>& local_binders() const {
76     return local_binders_;
77   }
clear_local_binders()78   void clear_local_binders() { local_binders_.clear(); }
79 
set_calling_uid(uid_t uid)80   void set_calling_uid(uid_t uid) { calling_uid_ = uid; }
set_calling_pid(pid_t pid)81   void set_calling_pid(pid_t pid) { calling_pid_ = pid; }
82 
83   // Sets the binder to return when |service_name| is passed to GetService() or
84   // WaitForService().
85   void SetBinderForService(const std::string& service_name,
86                            const sp<IBinder>& binder);
87 
88   // Returns the binder previously registered for |service_name| via
89   // RegisterService(), or null if the service hasn't been registered.
90   sp<IBinder> GetRegisteredService(const std::string& service_name) const;
91 
92   // Run the calback in |death_callbacks_| corresponding to |binder|.
93   void NotifyAboutBinderDeath(const sp<IBinder>& binder);
94 
95   // BinderWrapper:
96   sp<IBinder> GetService(const std::string& service_name) override;
97   bool RegisterService(const std::string& service_name,
98                        const sp<IBinder>& binder) override;
99   sp<BBinder> CreateLocalBinder() override;
100   bool RegisterForDeathNotifications(const sp<IBinder>& binder,
101                                      const ::base::Closure& callback) override;
102   bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
103   uid_t GetCallingUid() override;
104   pid_t GetCallingPid() override;
105 
106  private:
107   using ServiceMap = std::map<std::string, sp<IBinder>>;
108 
109   // Map from service name to associated binder handle. Used by GetService() and
110   // WaitForService().
111   ServiceMap services_to_return_;
112 
113   // Map from service name to associated binder handle. Updated by
114   // RegisterService().
115   ServiceMap registered_services_;
116 
117   // Local binders returned by CreateLocalBinder().
118   std::vector<sp<BBinder>> local_binders_;
119 
120   // Map from binder handle to the callback that should be invoked on binder
121   // death.
122   std::map<sp<IBinder>, ::base::Closure> death_callbacks_;
123 
124   // Values to return from GetCallingUid() and GetCallingPid();
125   uid_t calling_uid_;
126   pid_t calling_pid_;
127 
128   DISALLOW_COPY_AND_ASSIGN(StubBinderWrapper);
129 };
130 
131 }  // namespace android
132 
133 #endif  // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
134