Only affects debug build.

Add GBinderBridge

It acts as a proxy between two binder devices.

This version works for binder transactions which only
pass serialized data back and forth. Passing remote
object references is not yet supported.

This more or less ensures that responses get handled by the right thread
and allows to simulate more sophisticated test cases.

If there's no data, buffer may be NULL.

Fix a threading issue + assorted changes

Make sure that transaction handlers don't get invoked on a worker thread.
It was possible in cases if an incoming transaction arrives while we are
waiting for response from an asynchronous call to servicemanager (which
is actually a synchronous call made on a worker thread).

Invoking callbacks on a worker thread would completely break libgbinder's
synchronization model. It was a pretty unlikely scenario, though.

GBinderFds - native_handle_t
GBinderHidlHandle - struct hidl_handle
GBinderHidlMemory - struct hidl_memory

Except for one-way transactions where it would meaningless.

For better compile time diagnostics.

Also made ServiceManagerAidl a GBinderLocalObject-derived class to prepare
for possibly making it (deriving classes from GBinderLocalObject) a public
functionality.

It's something I've always had in mind. It's still an internal API
but it's quite likely that at some point it will be made public.
For now it's only going to be used by unit tests.

Fix random unit text failures

If a test calls test_binder_set_looper_enabled(fd, TRUE) to enable
processing of incoming data by the looper thread, the same thread
may get picked up by the next test and swallow the reply before the
transaction (for which the reply was intended) has been submitted.
Which may cause that next test to either fail or (if the transaction
was synchronous) block forever, stalling the build.

Calling gbinder_ipc_exit() makes sure that looper thread terminates
before the next test starts.

Use condition variable to signal closure of the last descriptor.

A few minor tweaks and another unit test

We must have looper running in order to receive death notifications.

And refactored binder simulator, it can now simulate a lot
more sophisticated scenarious.

It's needed by unit tests to make sure that asynchronous requests
get executed sequentially. Our binder simulation is too primitive
to handle truely overlapping requests.

Based on examination of servicemanager source code, it seems to be
a better idea because it's interpreted as a bitmask.

If the last GBinderIpc reference was dropped by the looper thread,
the exit flag wasn't set by gbinder_ipc_looper_stop() and such
looper thread kept hanging forever. Also, that flag wasn't checked
by gbinder_driver_read(), and even though it's even less likely
to cause any trouble in real life, let's fix that too.

Make protocol and service managers configurable per binder device

API level can be configured via libgbinder config file like this:

  [General]
  ApiLevel = 28

and that adds protocol and servicemanager values appropriate for
the specified Android API level.

Presets are currently defined for API levels 28 and 29.

It first appeared in Android 10 (API level 29)

It first appeared in Android 9 (API level 28)