Home | History | Annotate | Download | only in binderwrapper 
      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 
     75   const std::vector<sp<BBinder>>& local_binders() const {
     76     return local_binders_;
     77   }
     78   void clear_local_binders() { local_binders_.clear(); }
     79 
     80   void set_calling_uid(uid_t uid) { calling_uid_ = uid; }
     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