feat: add ServiceManager.AddService for publishing Go services

Add RegisterReceiver to the Transport interface so that
ServiceManager.AddService can register a TransactionReceiver with
the driver, obtain a cookie, and include the local binder object
in the addService parcel sent to the ServiceManager.

Author: xaionaro@dx.center

binder/transport.go

@@ -20,6 +20,11 @@ type Transport interface {
 	AcquireHandle(ctx context.Context, handle uint32) (_err error)
 	ReleaseHandle(ctx context.Context, handle uint32) (_err error)
 
+	RegisterReceiver(
+		ctx context.Context,
+		receiver TransactionReceiver,
+	) uintptr
+
 	RequestDeathNotification(
 		ctx context.Context,
 		handle uint32,

binder/versionaware/transport.go

@@ -644,6 +644,13 @@ func (t *Transport) ReleaseHandle(
 	return t.inner.ReleaseHandle(ctx, handle)
 }
 
+func (t *Transport) RegisterReceiver(
+	ctx context.Context,
+	receiver binder.TransactionReceiver,
+) uintptr {
+	return t.inner.RegisterReceiver(ctx, receiver)
+}
+
 func (t *Transport) RequestDeathNotification(
 	ctx context.Context,
 	handle uint32,

servicemanager/servicemanager.go

@@ -186,6 +186,51 @@ func (sm *ServiceManager) IsDeclared(
 	return val, nil
 }
 
+// AddService publishes a Go service under the given name so that other
+// processes can discover it via GetService/CheckService.
+func (sm *ServiceManager) AddService(
+	ctx context.Context,
+	name ServiceName,
+	service binder.TransactionReceiver,
+	allowIsolated bool,
+	dumpPriority int32,
+) (_err error) {
+	logger.Tracef(ctx, "AddService(%q)", name)
+	defer func() { logger.Tracef(ctx, "/AddService(%q): %v", name, _err) }()
+
+	transport := sm.transport()
+
+	cookie := transport.RegisterReceiver(ctx, service)
+
+	code, err := sm.remote.ResolveCode(serviceManagerDescriptor, "addService")
+	if err != nil {
+		return fmt.Errorf("servicemanager: AddService(%q): %w", name, err)
+	}
+
+	data := parcel.New()
+	data.WriteInterfaceToken(serviceManagerDescriptor)
+	data.WriteString16(string(name))
+	data.WriteLocalBinder(cookie)
+
+	var allowIsolatedInt int32
+	if allowIsolated {
+		allowIsolatedInt = 1
+	}
+	data.WriteInt32(allowIsolatedInt)
+	data.WriteInt32(dumpPriority)
+
+	reply, err := sm.remote.Transact(ctx, code, 0, data)
+	if err != nil {
+		return fmt.Errorf("servicemanager: AddService(%q): %w", name, err)
+	}
+
+	if err := binder.ReadStatus(reply); err != nil {
+		return fmt.Errorf("servicemanager: AddService(%q): %w", name, err)
+	}
+
+	return nil
+}
+
 // transport extracts the VersionAwareTransport from the ProxyBinder.
 func (sm *ServiceManager) transport() binder.VersionAwareTransport {
 	pb, ok := sm.remote.(*binder.ProxyBinder)

servicemanager/servicemanager_test.go

@@ -13,12 +13,14 @@ import (
 
 // mockTransport captures the last Transact call and returns a predetermined reply.
 type mockTransport struct {
-	lastHandle uint32
-	lastCode   binder.TransactionCode
-	lastFlags  binder.TransactionFlags
-	lastData   *parcel.Parcel
-	replyFunc  func() *parcel.Parcel
-	err        error
+	lastHandle   uint32
+	lastCode     binder.TransactionCode
+	lastFlags    binder.TransactionFlags
+	lastData     *parcel.Parcel
+	replyFunc    func() *parcel.Parcel
+	err          error
+	lastReceiver binder.TransactionReceiver
+	nextCookie   uintptr
 }
 
 func (m *mockTransport) Transact(
@@ -38,8 +40,13 @@ func (m *mockTransport) Transact(
 	return m.replyFunc(), nil
 }
 
-func (m *mockTransport) AcquireHandle(_ context.Context, _ uint32) error { return nil }
-func (m *mockTransport) ReleaseHandle(_ context.Context, _ uint32) error { return nil }
+func (m *mockTransport) AcquireHandle(_ context.Context, _ uint32) error  { return nil }
+func (m *mockTransport) ReleaseHandle(_ context.Context, _ uint32) error  { return nil }
+func (m *mockTransport) RegisterReceiver(_ context.Context, receiver binder.TransactionReceiver) uintptr {
+	m.lastReceiver = receiver
+	m.nextCookie++
+	return m.nextCookie
+}
 
 func (m *mockTransport) RequestDeathNotification(
 	_ context.Context,
@@ -262,3 +269,118 @@ func TestGetService_TransportError(t *testing.T) {
 	assert.Nil(t, result)
 	assert.ErrorIs(t, err, assert.AnError)
 }
+
+// mockReceiver is a minimal TransactionReceiver for testing.
+type mockReceiver struct{}
+
+func (r *mockReceiver) OnTransaction(
+	_ context.Context,
+	_ binder.TransactionCode,
+	_ *parcel.Parcel,
+) (*parcel.Parcel, error) {
+	return parcel.New(), nil
+}
+
+func TestAddService(t *testing.T) {
+	ctx := context.Background()
+
+	mt := &mockTransport{
+		replyFunc: buildSuccessReply(func(_ *parcel.Parcel) {}),
+	}
+
+	receiver := &mockReceiver{}
+	sm := New(mt)
+	err := sm.AddService(ctx, ServiceName("my.new.service"), receiver, true, 4)
+	require.NoError(t, err)
+
+	// Verify the receiver was registered.
+	assert.Equal(t, binder.TransactionReceiver(receiver), mt.lastReceiver)
+
+	// Verify we sent to handle 0 (ServiceManager) with correct code.
+	assert.Equal(t, uint32(0), mt.lastHandle)
+	assert.Equal(t, binder.FirstCallTransaction, mt.lastCode)
+	assert.Equal(t, binder.TransactionFlags(0), mt.lastFlags)
+
+	// Verify the sent parcel data.
+	mt.lastData.SetPosition(0)
+
+	token, err := mt.lastData.ReadInterfaceToken()
+	require.NoError(t, err)
+	assert.Equal(t, serviceManagerDescriptor, token)
+
+	svcName, err := mt.lastData.ReadString16()
+	require.NoError(t, err)
+	assert.Equal(t, "my.new.service", svcName)
+
+	// Read the local binder object (flat_binder_object).
+	handle, err := mt.lastData.ReadStrongBinder()
+	require.NoError(t, err)
+	// The cookie is 1 (first call to RegisterReceiver on this mock).
+	assert.Equal(t, uint32(1), handle)
+
+	// allowIsolated = true -> 1
+	allowIsolated, err := mt.lastData.ReadInt32()
+	require.NoError(t, err)
+	assert.Equal(t, int32(1), allowIsolated)
+
+	// dumpPriority = 4
+	dumpPriority, err := mt.lastData.ReadInt32()
+	require.NoError(t, err)
+	assert.Equal(t, int32(4), dumpPriority)
+}
+
+func TestAddService_NotIsolated(t *testing.T) {
+	ctx := context.Background()
+
+	mt := &mockTransport{
+		replyFunc: buildSuccessReply(func(_ *parcel.Parcel) {}),
+	}
+
+	sm := New(mt)
+	err := sm.AddService(ctx, ServiceName("isolated.service"), &mockReceiver{}, false, 0)
+	require.NoError(t, err)
+
+	// Verify allowIsolated is written as 0.
+	mt.lastData.SetPosition(0)
+	_, _ = mt.lastData.ReadInterfaceToken()
+	_, _ = mt.lastData.ReadString16()
+	_, _ = mt.lastData.ReadStrongBinder()
+
+	allowIsolated, err := mt.lastData.ReadInt32()
+	require.NoError(t, err)
+	assert.Equal(t, int32(0), allowIsolated)
+}
+
+func TestAddService_StatusError(t *testing.T) {
+	ctx := context.Background()
+
+	mt := &mockTransport{
+		replyFunc: func() *parcel.Parcel {
+			p := parcel.New()
+			binder.WriteStatus(p, &aidlerrors.StatusError{
+				Exception: aidlerrors.ExceptionSecurity,
+				Message:   "not allowed",
+			})
+			p.SetPosition(0)
+			return p
+		},
+	}
+
+	sm := New(mt)
+	err := sm.AddService(ctx, ServiceName("blocked.service"), &mockReceiver{}, false, 0)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "not allowed")
+}
+
+func TestAddService_TransportError(t *testing.T) {
+	ctx := context.Background()
+
+	mt := &mockTransport{
+		err: assert.AnError,
+	}
+
+	sm := New(mt)
+	err := sm.AddService(ctx, ServiceName("fail.service"), &mockReceiver{}, false, 0)
+	require.Error(t, err)
+	assert.ErrorIs(t, err, assert.AnError)
+}