flywithu/android_framwork
1
0
Fork 0
mirror of https://github.com/ioacademy-jikim/android_framwork synced 2025-06-07 16:06:29 +00:00
Code Issues Releases Wiki Activity

9

Browse Source
This commit is contained in:
ioacademy-jikim 2018-06-15 10:55:16 +09:00
parent f3d74671fa
commit 7a0a2db279
53 changed files with 3849 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
04_day/binder_1/Android.bp Normal file
View File

@ -0,0 +1,35 @@
cc_defaults {
name: "my_flags_2",
cflags: [
"-Wall",
"-Wextra",
"-Werror",
],
product_variables: {
binder32bit: {
cflags: ["-DBINDER_IPC_32BIT=1"],
},
},
shared_libs: ["liblog"],
}
cc_binary {
name: "my_server_2",
defaults: ["my_flags_2"],
srcs: [
"my_server.c",
"binder.c",
],
}
cc_binary {
name: "my_client_2",
defaults: ["my_flags_2"],
srcs: [
"my_client.c",
"binder.c",
],
}

107
04_day/binder_1/bctest.c Normal file
View File

@ -0,0 +1,107 @@
/* Copyright 2008 The Android Open Source Project
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
return 0;
handle = bio_get_ref(&reply);
if (handle)
binder_acquire(bs, handle);
binder_done(bs, &msg, &reply);
return handle;
}
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
int status;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
bio_put_obj(&msg, ptr);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
return -1;
status = bio_get_uint32(&reply);
binder_done(bs, &msg, &reply);
return status;
}
unsigned token;
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
uint32_t handle;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
argc--;
argv++;
while (argc > 0) {
if (!strcmp(argv[0],"alt")) {
handle = svcmgr_lookup(bs, svcmgr, "alt_svc_mgr");
if (!handle) {
fprintf(stderr,"cannot find alt_svc_mgr\n");
return -1;
}
svcmgr = handle;
fprintf(stderr,"svcmgr is via %x\n", handle);
} else if (!strcmp(argv[0],"lookup")) {
if (argc < 2) {
fprintf(stderr,"argument required\n");
return -1;
}
handle = svcmgr_lookup(bs, svcmgr, argv[1]);
fprintf(stderr,"lookup(%s) = %x\n", argv[1], handle);
argc--;
argv++;
} else if (!strcmp(argv[0],"publish")) {
if (argc < 2) {
fprintf(stderr,"argument required\n");
return -1;
}
svcmgr_publish(bs, svcmgr, argv[1], &token);
argc--;
argv++;
} else {
fprintf(stderr,"unknown command %s\n", argv[0]);
return -1;
}
argc--;
argv++;
}
return 0;
}

656
04_day/binder_1/binder.c Normal file
View File

@ -0,0 +1,656 @@
/* Copyright 2008 The Android Open Source Project
*/
#define LOG_TAG "Binder"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <log/log.h>
#include "binder.h"
#define MAX_BIO_SIZE (1 << 30)
#define TRACE 0
void bio_init_from_txn(struct binder_io *io, struct binder_transaction_data *txn);
#if TRACE
void hexdump(void *_data, size_t len)
{
unsigned char *data = _data;
size_t count;
for (count = 0; count < len; count++) {
if ((count & 15) == 0)
fprintf(stderr,"%04zu:", count);
fprintf(stderr," %02x %c", *data,
(*data < 32) || (*data > 126) ? '.' : *data);
data++;
if ((count & 15) == 15)
fprintf(stderr,"\n");
}
if ((count & 15) != 0)
fprintf(stderr,"\n");
}
void binder_dump_txn(struct binder_transaction_data *txn)
{
struct flat_binder_object *obj;
binder_size_t *offs = (binder_size_t *)(uintptr_t)txn->data.ptr.offsets;
size_t count = txn->offsets_size / sizeof(binder_size_t);
fprintf(stderr," target %016"PRIx64" cookie %016"PRIx64" code %08x flags %08x\n",
(uint64_t)txn->target.ptr, (uint64_t)txn->cookie, txn->code, txn->flags);
fprintf(stderr," pid %8d uid %8d data %"PRIu64" offs %"PRIu64"\n",
txn->sender_pid, txn->sender_euid, (uint64_t)txn->data_size, (uint64_t)txn->offsets_size);
hexdump((void *)(uintptr_t)txn->data.ptr.buffer, txn->data_size);
while (count--) {
obj = (struct flat_binder_object *) (((char*)(uintptr_t)txn->data.ptr.buffer) + *offs++);
fprintf(stderr," - type %08x flags %08x ptr %016"PRIx64" cookie %016"PRIx64"\n",
obj->type, obj->flags, (uint64_t)obj->binder, (uint64_t)obj->cookie);
}
}
#define NAME(n) case n: return #n
const char *cmd_name(uint32_t cmd)
{
switch(cmd) {
NAME(BR_NOOP);
NAME(BR_TRANSACTION_COMPLETE);
NAME(BR_INCREFS);
NAME(BR_ACQUIRE);
NAME(BR_RELEASE);
NAME(BR_DECREFS);
NAME(BR_TRANSACTION);
NAME(BR_REPLY);
NAME(BR_FAILED_REPLY);
NAME(BR_DEAD_REPLY);
NAME(BR_DEAD_BINDER);
default: return "???";
}
}
#else
#define hexdump(a,b) do{} while (0)
#define binder_dump_txn(txn) do{} while (0)
#endif
#define BIO_F_SHARED 0x01 /* needs to be buffer freed */
#define BIO_F_OVERFLOW 0x02 /* ran out of space */
#define BIO_F_IOERROR 0x04
#define BIO_F_MALLOCED 0x08 /* needs to be free()'d */
struct binder_state
{
int fd;
void *mapped;
size_t mapsize;
};
struct binder_state *binder_open(const char* driver, size_t mapsize)
{
struct binder_state *bs;
struct binder_version vers;
bs = malloc(sizeof(*bs));
if (!bs) {
errno = ENOMEM;
return NULL;
}
bs->fd = open(driver, O_RDWR | O_CLOEXEC);
if (bs->fd < 0) {
fprintf(stderr,"binder: cannot open %s (%s)\n",
driver, strerror(errno));
goto fail_open;
}
if ((ioctl(bs->fd, BINDER_VERSION, &vers) == -1) ||
(vers.protocol_version != BINDER_CURRENT_PROTOCOL_VERSION)) {
fprintf(stderr,
"binder: kernel driver version (%d) differs from user space version (%d)\n",
vers.protocol_version, BINDER_CURRENT_PROTOCOL_VERSION);
goto fail_open;
}
bs->mapsize = mapsize;
bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);
if (bs->mapped == MAP_FAILED) {
fprintf(stderr,"binder: cannot map device (%s)\n",
strerror(errno));
goto fail_map;
}
return bs;
fail_map:
close(bs->fd);
fail_open:
free(bs);
return NULL;
}
void binder_close(struct binder_state *bs)
{
munmap(bs->mapped, bs->mapsize);
close(bs->fd);
free(bs);
}
int binder_become_context_manager(struct binder_state *bs)
{
return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);
}
int binder_write(struct binder_state *bs, void *data, size_t len)
{
struct binder_write_read bwr;
int res;
bwr.write_size = len;
bwr.write_consumed = 0;
bwr.write_buffer = (uintptr_t) data;
bwr.read_size = 0;
bwr.read_consumed = 0;
bwr.read_buffer = 0;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
fprintf(stderr,"binder_write: ioctl failed (%s)\n",
strerror(errno));
}
return res;
}
void binder_free_buffer(struct binder_state *bs,
binder_uintptr_t buffer_to_free)
{
struct {
uint32_t cmd_free;
binder_uintptr_t buffer;
} __attribute__((packed)) data;
data.cmd_free = BC_FREE_BUFFER;
data.buffer = buffer_to_free;
binder_write(bs, &data, sizeof(data));
}
void binder_send_reply(struct binder_state *bs,
struct binder_io *reply,
binder_uintptr_t buffer_to_free,
int status)
{
struct {
uint32_t cmd_free;
binder_uintptr_t buffer;
uint32_t cmd_reply;
struct binder_transaction_data txn;
} __attribute__((packed)) data;
data.cmd_free = BC_FREE_BUFFER;
data.buffer = buffer_to_free;
data.cmd_reply = BC_REPLY;
data.txn.target.ptr = 0;
data.txn.cookie = 0;
data.txn.code = 0;
if (status) {
data.txn.flags = TF_STATUS_CODE;
data.txn.data_size = sizeof(int);
data.txn.offsets_size = 0;
data.txn.data.ptr.buffer = (uintptr_t)&status;
data.txn.data.ptr.offsets = 0;
} else {
data.txn.flags = 0;
data.txn.data_size = reply->data - reply->data0;
data.txn.offsets_size = ((char*) reply->offs) - ((char*) reply->offs0);
data.txn.data.ptr.buffer = (uintptr_t)reply->data0;
data.txn.data.ptr.offsets = (uintptr_t)reply->offs0;
}
binder_write(bs, &data, sizeof(data));
}
int binder_parse(struct binder_state *bs, struct binder_io *bio,
uintptr_t ptr, size_t size, binder_handler func)
{
int r = 1;
uintptr_t end = ptr + (uintptr_t) size;
while (ptr < end) {
uint32_t cmd = *(uint32_t *) ptr;
ptr += sizeof(uint32_t);
#if TRACE
fprintf(stderr,"%s:\n", cmd_name(cmd));
#endif
switch(cmd) {
case BR_NOOP:
break;
case BR_TRANSACTION_COMPLETE:
break;
case BR_INCREFS:
case BR_ACQUIRE:
case BR_RELEASE:
case BR_DECREFS:
#if TRACE
fprintf(stderr," %p, %p\n", (void *)ptr, (void *)(ptr + sizeof(void *)));
#endif
ptr += sizeof(struct binder_ptr_cookie);
break;
case BR_TRANSACTION: {
struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
if ((end - ptr) < sizeof(*txn)) {
ALOGE("parse: txn too small!\n");
return -1;
}
binder_dump_txn(txn);
if (func) {
unsigned rdata[256/4];
struct binder_io msg;
struct binder_io reply;
int res;
bio_init(&reply, rdata, sizeof(rdata), 4);
bio_init_from_txn(&msg, txn);
res = func(bs, txn, &msg, &reply);
if (txn->flags & TF_ONE_WAY) {
binder_free_buffer(bs, txn->data.ptr.buffer);
} else {
binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
}
}
ptr += sizeof(*txn);
break;
}
case BR_REPLY: {
struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
if ((end - ptr) < sizeof(*txn)) {
ALOGE("parse: reply too small!\n");
return -1;
}
binder_dump_txn(txn);
if (bio) {
bio_init_from_txn(bio, txn);
bio = 0;
} else {
/* todo FREE BUFFER */
}
ptr += sizeof(*txn);
r = 0;
break;
}
case BR_DEAD_BINDER: {
struct binder_death *death = (struct binder_death *)(uintptr_t) *(binder_uintptr_t *)ptr;
ptr += sizeof(binder_uintptr_t);
death->func(bs, death->ptr);
break;
}
case BR_FAILED_REPLY:
r = -1;
break;
case BR_DEAD_REPLY:
r = -1;
break;
default:
ALOGE("parse: OOPS %d\n", cmd);
return -1;
}
}
return r;
}
void binder_acquire(struct binder_state *bs, uint32_t target)
{
uint32_t cmd[2];
cmd[0] = BC_ACQUIRE;
cmd[1] = target;
binder_write(bs, cmd, sizeof(cmd));
}
void binder_release(struct binder_state *bs, uint32_t target)
{
uint32_t cmd[2];
cmd[0] = BC_RELEASE;
cmd[1] = target;
binder_write(bs, cmd, sizeof(cmd));
}
void binder_link_to_death(struct binder_state *bs, uint32_t target, struct binder_death *death)
{
struct {
uint32_t cmd;
struct binder_handle_cookie payload;
} __attribute__((packed)) data;
data.cmd = BC_REQUEST_DEATH_NOTIFICATION;
data.payload.handle = target;
data.payload.cookie = (uintptr_t) death;
binder_write(bs, &data, sizeof(data));
}
int binder_call(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply,
uint32_t target, uint32_t code)
{
int res;
struct binder_write_read bwr;
struct {
uint32_t cmd;
struct binder_transaction_data txn;
} __attribute__((packed)) writebuf;
unsigned readbuf[32];
if (msg->flags & BIO_F_OVERFLOW) {
fprintf(stderr,"binder: txn buffer overflow\n");
goto fail;
}
writebuf.cmd = BC_TRANSACTION;
writebuf.txn.target.handle = target;
writebuf.txn.code = code;
writebuf.txn.flags = 0;
writebuf.txn.data_size = msg->data - msg->data0;
writebuf.txn.offsets_size = ((char*) msg->offs) - ((char*) msg->offs0);
writebuf.txn.data.ptr.buffer = (uintptr_t)msg->data0;
writebuf.txn.data.ptr.offsets = (uintptr_t)msg->offs0;
bwr.write_size = sizeof(writebuf);
bwr.write_consumed = 0;
bwr.write_buffer = (uintptr_t) &writebuf;
hexdump(msg->data0, msg->data - msg->data0);
for (;;) {
bwr.read_size = sizeof(readbuf);
bwr.read_consumed = 0;
bwr.read_buffer = (uintptr_t) readbuf;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
fprintf(stderr,"binder: ioctl failed (%s)\n", strerror(errno));
goto fail;
}
res = binder_parse(bs, reply, (uintptr_t) readbuf, bwr.read_consumed, 0);
if (res == 0) return 0;
if (res < 0) goto fail;
}
fail:
memset(reply, 0, sizeof(*reply));
reply->flags |= BIO_F_IOERROR;
return -1;
}
void binder_loop(struct binder_state *bs, binder_handler func)
{
int res;
struct binder_write_read bwr;
uint32_t readbuf[32];
bwr.write_size = 0;
bwr.write_consumed = 0;
bwr.write_buffer = 0;
readbuf[0] = BC_ENTER_LOOPER;
binder_write(bs, readbuf, sizeof(uint32_t));
for (;;) {
bwr.read_size = sizeof(readbuf);
bwr.read_consumed = 0;
bwr.read_buffer = (uintptr_t) readbuf;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
break;
}
res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
if (res == 0) {
ALOGE("binder_loop: unexpected reply?!\n");
break;
}
if (res < 0) {
ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
break;
}
}
}
void bio_init_from_txn(struct binder_io *bio, struct binder_transaction_data *txn)
{
bio->data = bio->data0 = (char *)(intptr_t)txn->data.ptr.buffer;
bio->offs = bio->offs0 = (binder_size_t *)(intptr_t)txn->data.ptr.offsets;
bio->data_avail = txn->data_size;
bio->offs_avail = txn->offsets_size / sizeof(size_t);
bio->flags = BIO_F_SHARED;
}
void bio_init(struct binder_io *bio, void *data,
size_t maxdata, size_t maxoffs)
{
size_t n = maxoffs * sizeof(size_t);
if (n > maxdata) {
bio->flags = BIO_F_OVERFLOW;
bio->data_avail = 0;
bio->offs_avail = 0;
return;
}
bio->data = bio->data0 = (char *) data + n;
bio->offs = bio->offs0 = data;
bio->data_avail = maxdata - n;
bio->offs_avail = maxoffs;
bio->flags = 0;
}
static void *bio_alloc(struct binder_io *bio, size_t size)
{
size = (size + 3) & (~3);
if (size > bio->data_avail) {
bio->flags |= BIO_F_OVERFLOW;
return NULL;
} else {
void *ptr = bio->data;
bio->data += size;
bio->data_avail -= size;
return ptr;
}
}
void binder_done(struct binder_state *bs,
__unused struct binder_io *msg,
struct binder_io *reply)
{
struct {
uint32_t cmd;
uintptr_t buffer;
} __attribute__((packed)) data;
if (reply->flags & BIO_F_SHARED) {
data.cmd = BC_FREE_BUFFER;
data.buffer = (uintptr_t) reply->data0;
binder_write(bs, &data, sizeof(data));
reply->flags = 0;
}
}
static struct flat_binder_object *bio_alloc_obj(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = bio_alloc(bio, sizeof(*obj));
if (obj && bio->offs_avail) {
bio->offs_avail--;
*bio->offs++ = ((char*) obj) - ((char*) bio->data0);
return obj;
}
bio->flags |= BIO_F_OVERFLOW;
return NULL;
}
void bio_put_uint32(struct binder_io *bio, uint32_t n)
{
uint32_t *ptr = bio_alloc(bio, sizeof(n));
if (ptr)
*ptr = n;
}
void bio_put_obj(struct binder_io *bio, void *ptr)
{
struct flat_binder_object *obj;
obj = bio_alloc_obj(bio);
if (!obj)
return;
obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
obj->type = BINDER_TYPE_BINDER;
obj->binder = (uintptr_t)ptr;
obj->cookie = 0;
}
void bio_put_ref(struct binder_io *bio, uint32_t handle)
{
struct flat_binder_object *obj;
if (handle)
obj = bio_alloc_obj(bio);
else
obj = bio_alloc(bio, sizeof(*obj));
if (!obj)
return;
obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
obj->type = BINDER_TYPE_HANDLE;
obj->handle = handle;
obj->cookie = 0;
}
void bio_put_string16(struct binder_io *bio, const uint16_t *str)
{
size_t len;
uint16_t *ptr;
if (!str) {
bio_put_uint32(bio, 0xffffffff);
return;
}
len = 0;
while (str[len]) len++;
if (len >= (MAX_BIO_SIZE / sizeof(uint16_t))) {
bio_put_uint32(bio, 0xffffffff);
return;
}
/* Note: The payload will carry 32bit size instead of size_t */
bio_put_uint32(bio, (uint32_t) len);
len = (len + 1) * sizeof(uint16_t);
ptr = bio_alloc(bio, len);
if (ptr)
memcpy(ptr, str, len);
}
void bio_put_string16_x(struct binder_io *bio, const char *_str)
{
unsigned char *str = (unsigned char*) _str;
size_t len;
uint16_t *ptr;
if (!str) {
bio_put_uint32(bio, 0xffffffff);
return;
}
len = strlen(_str);
if (len >= (MAX_BIO_SIZE / sizeof(uint16_t))) {
bio_put_uint32(bio, 0xffffffff);
return;
}
/* Note: The payload will carry 32bit size instead of size_t */
bio_put_uint32(bio, len);
ptr = bio_alloc(bio, (len + 1) * sizeof(uint16_t));
if (!ptr)
return;
while (*str)
*ptr++ = *str++;
*ptr++ = 0;
}
static void *bio_get(struct binder_io *bio, size_t size)
{
size = (size + 3) & (~3);
if (bio->data_avail < size){
bio->data_avail = 0;
bio->flags |= BIO_F_OVERFLOW;
return NULL;
} else {
void *ptr = bio->data;
bio->data += size;
bio->data_avail -= size;
return ptr;
}
}
uint32_t bio_get_uint32(struct binder_io *bio)
{
uint32_t *ptr = bio_get(bio, sizeof(*ptr));
return ptr ? *ptr : 0;
}
uint16_t *bio_get_string16(struct binder_io *bio, size_t *sz)
{
size_t len;
/* Note: The payload will carry 32bit size instead of size_t */
len = (size_t) bio_get_uint32(bio);
if (sz)
*sz = len;
return bio_get(bio, (len + 1) * sizeof(uint16_t));
}
static struct flat_binder_object *_bio_get_obj(struct binder_io *bio)
{
size_t n;
size_t off = bio->data - bio->data0;
/* TODO: be smarter about this? */
for (n = 0; n < bio->offs_avail; n++) {
if (bio->offs[n] == off)
return bio_get(bio, sizeof(struct flat_binder_object));
}
bio->data_avail = 0;
bio->flags |= BIO_F_OVERFLOW;
return NULL;
}
uint32_t bio_get_ref(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = _bio_get_obj(bio);
if (!obj)
return 0;
if (obj->type == BINDER_TYPE_HANDLE)
return obj->handle;
return 0;
}

73
04_day/binder_1/binder.h Normal file
View File

@ -0,0 +1,73 @@
/* Copyright 2008 The Android Open Source Project
*/
#ifndef _BINDER_H_
#define _BINDER_H_
#include <sys/ioctl.h>
#include <linux/android/binder.h>
struct binder_state;
struct binder_io
{
char *data; /* pointer to read/write from */
binder_size_t *offs; /* array of offsets */
size_t data_avail; /* bytes available in data buffer */
size_t offs_avail; /* entries available in offsets array */
char *data0; /* start of data buffer */
binder_size_t *offs0; /* start of offsets buffer */
uint32_t flags;
uint32_t unused;
};
struct binder_death {
void (*func)(struct binder_state *bs, void *ptr);
void *ptr;
};
/* the one magic handle */
#define BINDER_SERVICE_MANAGER 0U
#define SVC_MGR_NAME "android.os.IServiceManager"
enum {
/* Must match definitions in IBinder.h and IServiceManager.h */
PING_TRANSACTION = B_PACK_CHARS('_','P','N','G'),
SVC_MGR_GET_SERVICE = 1,
SVC_MGR_CHECK_SERVICE,
SVC_MGR_ADD_SERVICE,
SVC_MGR_LIST_SERVICES,
};
typedef int (*binder_handler)(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply);
struct binder_state *binder_open(const char* driver, size_t mapsize);
void binder_close(struct binder_state *bs);
/* initiate a blocking binder call
* - returns zero on success
*/
int binder_call(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply,
uint32_t target, uint32_t code);
/* release any state associate with the binder_io
* - call once any necessary data has been extracted from the
* binder_io after binder_call() returns
* - can safely be called even if binder_call() fails
*/
void binder_done(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply);
/* manipulate strong references */
void binder_acquire(struct binder_state *bs, uint32_t target);
void binder_release(struct binder_state *bs, uint32_t target);
void binder_link_to_death(struct binder_state *bs, uint32_t target, struct binder_death *death);
void binder_loop(struct binder_state *bs, binder_handler func);
int binder_become_context_manager(struct binder_state *bs);
/* allocate a binder_io, providing a stack-allocated working
* buffer, size of the working buffer, and how many object
* offset entries to reserve from the buffer
*/
void bio_init(struct binder_io *bio, void *data,
size_t maxdata, size_t maxobjects);
void bio_put_obj(struct binder_io *bio, void *ptr);
void bio_put_ref(struct binder_io *bio, uint32_t handle);
void bio_put_uint32(struct binder_io *bio, uint32_t n);
void bio_put_string16(struct binder_io *bio, const uint16_t *str);
void bio_put_string16_x(struct binder_io *bio, const char *_str);
uint32_t bio_get_uint32(struct binder_io *bio);
uint16_t *bio_get_string16(struct binder_io *bio, size_t *sz);
uint32_t bio_get_ref(struct binder_io *bio);
#endif

54
04_day/binder_1/my_client.c Normal file
View File

@ -0,0 +1,54 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
return 0;
handle = bio_get_ref(&reply);
if (handle)
binder_acquire(bs, handle);
binder_done(bs, &msg, &reply);
return handle;
}
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
handle = svcmgr_lookup(bs, svcmgr, argv[argc-1]);
fprintf(stderr,"lookup(%s) = %x\n", argv[argc-1], handle);
bio_init(&msg, iodata, sizeof(iodata), 4);
binder_call(bs, &msg, &reply, handle, 1);
return 0;
}

74
04_day/binder_1/my_server.c Normal file
View File

@ -0,0 +1,74 @@
/* Copyright 2008 The Android Open Source Project
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
int status;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
bio_put_obj(&msg, ptr);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
return -1;
status = bio_get_uint32(&reply);
binder_done(bs, &msg, &reply);
return status;
}
int my_handler(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply)
{
printf("my_handler %p %p %p %p\n", bs, txn, msg, reply);
switch(txn->code) {
case 1:
printf("Server : LED_ON, %p\n", (void*)txn->target.ptr);
return 0;
default:
printf("unknown code %d\n", txn->code);
return -1;
}
bio_put_uint32(reply, 0);
return 0;
}
unsigned token;
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
printf("Server : &token = %p\n", &token );
svcmgr_publish(bs, svcmgr, argv[argc-1], &token);
binder_loop(bs, my_handler);
return 0;
}

35
04_day/binder_2/Android.bp Normal file
View File

@ -0,0 +1,35 @@
cc_defaults {
name: "my_flags_3",
cflags: [
"-Wall",
"-Wextra",
"-Werror",
],
product_variables: {
binder32bit: {
cflags: ["-DBINDER_IPC_32BIT=1"],
},
},
shared_libs: ["liblog"],
}
cc_binary {
name: "my_server_3",
defaults: ["my_flags_3"],
srcs: [
"my_server.c",
"binder.c",
],
}
cc_binary {
name: "my_client_3",
defaults: ["my_flags_3"],
srcs: [
"my_client.c",
"binder.c",
],
}

107
04_day/binder_2/bctest.c Normal file
View File

@ -0,0 +1,107 @@
/* Copyright 2008 The Android Open Source Project
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
return 0;
handle = bio_get_ref(&reply);
if (handle)
binder_acquire(bs, handle);
binder_done(bs, &msg, &reply);
return handle;
}
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
int status;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
bio_put_obj(&msg, ptr);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
return -1;
status = bio_get_uint32(&reply);
binder_done(bs, &msg, &reply);
return status;
}
unsigned token;
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
uint32_t handle;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
argc--;
argv++;
while (argc > 0) {
if (!strcmp(argv[0],"alt")) {
handle = svcmgr_lookup(bs, svcmgr, "alt_svc_mgr");
if (!handle) {
fprintf(stderr,"cannot find alt_svc_mgr\n");
return -1;
}
svcmgr = handle;
fprintf(stderr,"svcmgr is via %x\n", handle);
} else if (!strcmp(argv[0],"lookup")) {
if (argc < 2) {
fprintf(stderr,"argument required\n");
return -1;
}
handle = svcmgr_lookup(bs, svcmgr, argv[1]);
fprintf(stderr,"lookup(%s) = %x\n", argv[1], handle);
argc--;
argv++;
} else if (!strcmp(argv[0],"publish")) {
if (argc < 2) {
fprintf(stderr,"argument required\n");
return -1;
}
svcmgr_publish(bs, svcmgr, argv[1], &token);
argc--;
argv++;
} else {
fprintf(stderr,"unknown command %s\n", argv[0]);
return -1;
}
argc--;
argv++;
}
return 0;
}

656
04_day/binder_2/binder.c Normal file
View File

@ -0,0 +1,656 @@
/* Copyright 2008 The Android Open Source Project
*/
#define LOG_TAG "Binder"
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <log/log.h>
#include "binder.h"
#define MAX_BIO_SIZE (1 << 30)
#define TRACE 0
void bio_init_from_txn(struct binder_io *io, struct binder_transaction_data *txn);
#if TRACE
void hexdump(void *_data, size_t len)
{
unsigned char *data = _data;
size_t count;
for (count = 0; count < len; count++) {
if ((count & 15) == 0)
fprintf(stderr,"%04zu:", count);
fprintf(stderr," %02x %c", *data,
(*data < 32) || (*data > 126) ? '.' : *data);
data++;
if ((count & 15) == 15)
fprintf(stderr,"\n");
}
if ((count & 15) != 0)
fprintf(stderr,"\n");
}
void binder_dump_txn(struct binder_transaction_data *txn)
{
struct flat_binder_object *obj;
binder_size_t *offs = (binder_size_t *)(uintptr_t)txn->data.ptr.offsets;
size_t count = txn->offsets_size / sizeof(binder_size_t);
fprintf(stderr," target %016"PRIx64" cookie %016"PRIx64" code %08x flags %08x\n",
(uint64_t)txn->target.ptr, (uint64_t)txn->cookie, txn->code, txn->flags);
fprintf(stderr," pid %8d uid %8d data %"PRIu64" offs %"PRIu64"\n",
txn->sender_pid, txn->sender_euid, (uint64_t)txn->data_size, (uint64_t)txn->offsets_size);
hexdump((void *)(uintptr_t)txn->data.ptr.buffer, txn->data_size);
while (count--) {
obj = (struct flat_binder_object *) (((char*)(uintptr_t)txn->data.ptr.buffer) + *offs++);
fprintf(stderr," - type %08x flags %08x ptr %016"PRIx64" cookie %016"PRIx64"\n",
obj->type, obj->flags, (uint64_t)obj->binder, (uint64_t)obj->cookie);
}
}
#define NAME(n) case n: return #n
const char *cmd_name(uint32_t cmd)
{
switch(cmd) {
NAME(BR_NOOP);
NAME(BR_TRANSACTION_COMPLETE);
NAME(BR_INCREFS);
NAME(BR_ACQUIRE);
NAME(BR_RELEASE);
NAME(BR_DECREFS);
NAME(BR_TRANSACTION);
NAME(BR_REPLY);
NAME(BR_FAILED_REPLY);
NAME(BR_DEAD_REPLY);
NAME(BR_DEAD_BINDER);
default: return "???";
}
}
#else
#define hexdump(a,b) do{} while (0)
#define binder_dump_txn(txn) do{} while (0)
#endif
#define BIO_F_SHARED 0x01 /* needs to be buffer freed */
#define BIO_F_OVERFLOW 0x02 /* ran out of space */
#define BIO_F_IOERROR 0x04
#define BIO_F_MALLOCED 0x08 /* needs to be free()'d */
struct binder_state
{
int fd;
void *mapped;
size_t mapsize;
};
struct binder_state *binder_open(const char* driver, size_t mapsize)
{
struct binder_state *bs;
struct binder_version vers;
bs = malloc(sizeof(*bs));
if (!bs) {
errno = ENOMEM;
return NULL;
}
bs->fd = open(driver, O_RDWR | O_CLOEXEC);
if (bs->fd < 0) {
fprintf(stderr,"binder: cannot open %s (%s)\n",
driver, strerror(errno));
goto fail_open;
}
if ((ioctl(bs->fd, BINDER_VERSION, &vers) == -1) ||
(vers.protocol_version != BINDER_CURRENT_PROTOCOL_VERSION)) {
fprintf(stderr,
"binder: kernel driver version (%d) differs from user space version (%d)\n",
vers.protocol_version, BINDER_CURRENT_PROTOCOL_VERSION);
goto fail_open;
}
bs->mapsize = mapsize;
bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);
if (bs->mapped == MAP_FAILED) {
fprintf(stderr,"binder: cannot map device (%s)\n",
strerror(errno));
goto fail_map;
}
return bs;
fail_map:
close(bs->fd);
fail_open:
free(bs);
return NULL;
}
void binder_close(struct binder_state *bs)
{
munmap(bs->mapped, bs->mapsize);
close(bs->fd);
free(bs);
}
int binder_become_context_manager(struct binder_state *bs)
{
return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);
}
int binder_write(struct binder_state *bs, void *data, size_t len)
{
struct binder_write_read bwr;
int res;
bwr.write_size = len;
bwr.write_consumed = 0;
bwr.write_buffer = (uintptr_t) data;
bwr.read_size = 0;
bwr.read_consumed = 0;
bwr.read_buffer = 0;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
fprintf(stderr,"binder_write: ioctl failed (%s)\n",
strerror(errno));
}
return res;
}
void binder_free_buffer(struct binder_state *bs,
binder_uintptr_t buffer_to_free)
{
struct {
uint32_t cmd_free;
binder_uintptr_t buffer;
} __attribute__((packed)) data;
data.cmd_free = BC_FREE_BUFFER;
data.buffer = buffer_to_free;
binder_write(bs, &data, sizeof(data));
}
void binder_send_reply(struct binder_state *bs,
struct binder_io *reply,
binder_uintptr_t buffer_to_free,
int status)
{
struct {
uint32_t cmd_free;
binder_uintptr_t buffer;
uint32_t cmd_reply;
struct binder_transaction_data txn;
} __attribute__((packed)) data;
data.cmd_free = BC_FREE_BUFFER;
data.buffer = buffer_to_free;
data.cmd_reply = BC_REPLY;
data.txn.target.ptr = 0;
data.txn.cookie = 0;
data.txn.code = 0;
if (status) {
data.txn.flags = TF_STATUS_CODE;
data.txn.data_size = sizeof(int);
data.txn.offsets_size = 0;
data.txn.data.ptr.buffer = (uintptr_t)&status;
data.txn.data.ptr.offsets = 0;
} else {
data.txn.flags = 0;
data.txn.data_size = reply->data - reply->data0;
data.txn.offsets_size = ((char*) reply->offs) - ((char*) reply->offs0);
data.txn.data.ptr.buffer = (uintptr_t)reply->data0;
data.txn.data.ptr.offsets = (uintptr_t)reply->offs0;
}
binder_write(bs, &data, sizeof(data));
}
int binder_parse(struct binder_state *bs, struct binder_io *bio,
uintptr_t ptr, size_t size, binder_handler func)
{
int r = 1;
uintptr_t end = ptr + (uintptr_t) size;
while (ptr < end) {
uint32_t cmd = *(uint32_t *) ptr;
ptr += sizeof(uint32_t);
#if TRACE
fprintf(stderr,"%s:\n", cmd_name(cmd));
#endif
switch(cmd) {
case BR_NOOP:
break;
case BR_TRANSACTION_COMPLETE:
break;
case BR_INCREFS:
case BR_ACQUIRE:
case BR_RELEASE:
case BR_DECREFS:
#if TRACE
fprintf(stderr," %p, %p\n", (void *)ptr, (void *)(ptr + sizeof(void *)));
#endif
ptr += sizeof(struct binder_ptr_cookie);
break;
case BR_TRANSACTION: {
struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
if ((end - ptr) < sizeof(*txn)) {
ALOGE("parse: txn too small!\n");
return -1;
}
binder_dump_txn(txn);
if (func) {
unsigned rdata[256/4];
struct binder_io msg;
struct binder_io reply;
int res;
bio_init(&reply, rdata, sizeof(rdata), 4);
bio_init_from_txn(&msg, txn);
res = func(bs, txn, &msg, &reply);
if (txn->flags & TF_ONE_WAY) {
binder_free_buffer(bs, txn->data.ptr.buffer);
} else {
binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
}
}
ptr += sizeof(*txn);
break;
}
case BR_REPLY: {
struct binder_transaction_data *txn = (struct binder_transaction_data *) ptr;
if ((end - ptr) < sizeof(*txn)) {
ALOGE("parse: reply too small!\n");
return -1;
}
binder_dump_txn(txn);
if (bio) {
bio_init_from_txn(bio, txn);
bio = 0;
} else {
/* todo FREE BUFFER */
}
ptr += sizeof(*txn);
r = 0;
break;
}
case BR_DEAD_BINDER: {
struct binder_death *death = (struct binder_death *)(uintptr_t) *(binder_uintptr_t *)ptr;
ptr += sizeof(binder_uintptr_t);
death->func(bs, death->ptr);
break;
}
case BR_FAILED_REPLY:
r = -1;
break;
case BR_DEAD_REPLY:
r = -1;
break;
default:
ALOGE("parse: OOPS %d\n", cmd);
return -1;
}
}
return r;
}
void binder_acquire(struct binder_state *bs, uint32_t target)
{
uint32_t cmd[2];
cmd[0] = BC_ACQUIRE;
cmd[1] = target;
binder_write(bs, cmd, sizeof(cmd));
}
void binder_release(struct binder_state *bs, uint32_t target)
{
uint32_t cmd[2];
cmd[0] = BC_RELEASE;
cmd[1] = target;
binder_write(bs, cmd, sizeof(cmd));
}
void binder_link_to_death(struct binder_state *bs, uint32_t target, struct binder_death *death)
{
struct {
uint32_t cmd;
struct binder_handle_cookie payload;
} __attribute__((packed)) data;
data.cmd = BC_REQUEST_DEATH_NOTIFICATION;
data.payload.handle = target;
data.payload.cookie = (uintptr_t) death;
binder_write(bs, &data, sizeof(data));
}
int binder_call(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply,
uint32_t target, uint32_t code)
{
int res;
struct binder_write_read bwr;
struct {
uint32_t cmd;
struct binder_transaction_data txn;
} __attribute__((packed)) writebuf;
unsigned readbuf[32];
if (msg->flags & BIO_F_OVERFLOW) {
fprintf(stderr,"binder: txn buffer overflow\n");
goto fail;
}
writebuf.cmd = BC_TRANSACTION;
writebuf.txn.target.handle = target;
writebuf.txn.code = code;
writebuf.txn.flags = 0;
writebuf.txn.data_size = msg->data - msg->data0;
writebuf.txn.offsets_size = ((char*) msg->offs) - ((char*) msg->offs0);
writebuf.txn.data.ptr.buffer = (uintptr_t)msg->data0;
writebuf.txn.data.ptr.offsets = (uintptr_t)msg->offs0;
bwr.write_size = sizeof(writebuf);
bwr.write_consumed = 0;
bwr.write_buffer = (uintptr_t) &writebuf;
hexdump(msg->data0, msg->data - msg->data0);
for (;;) {
bwr.read_size = sizeof(readbuf);
bwr.read_consumed = 0;
bwr.read_buffer = (uintptr_t) readbuf;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
fprintf(stderr,"binder: ioctl failed (%s)\n", strerror(errno));
goto fail;
}
res = binder_parse(bs, reply, (uintptr_t) readbuf, bwr.read_consumed, 0);
if (res == 0) return 0;
if (res < 0) goto fail;
}
fail:
memset(reply, 0, sizeof(*reply));
reply->flags |= BIO_F_IOERROR;
return -1;
}
void binder_loop(struct binder_state *bs, binder_handler func)
{
int res;
struct binder_write_read bwr;
uint32_t readbuf[32];
bwr.write_size = 0;
bwr.write_consumed = 0;
bwr.write_buffer = 0;
readbuf[0] = BC_ENTER_LOOPER;
binder_write(bs, readbuf, sizeof(uint32_t));
for (;;) {
bwr.read_size = sizeof(readbuf);
bwr.read_consumed = 0;
bwr.read_buffer = (uintptr_t) readbuf;
res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
if (res < 0) {
ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
break;
}
res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
if (res == 0) {
ALOGE("binder_loop: unexpected reply?!\n");
break;
}
if (res < 0) {
ALOGE("binder_loop: io error %d %s\n", res, strerror(errno));
break;
}
}
}
void bio_init_from_txn(struct binder_io *bio, struct binder_transaction_data *txn)
{
bio->data = bio->data0 = (char *)(intptr_t)txn->data.ptr.buffer;
bio->offs = bio->offs0 = (binder_size_t *)(intptr_t)txn->data.ptr.offsets;
bio->data_avail = txn->data_size;
bio->offs_avail = txn->offsets_size / sizeof(size_t);
bio->flags = BIO_F_SHARED;
}
void bio_init(struct binder_io *bio, void *data,
size_t maxdata, size_t maxoffs)
{
size_t n = maxoffs * sizeof(size_t);
if (n > maxdata) {
bio->flags = BIO_F_OVERFLOW;
bio->data_avail = 0;
bio->offs_avail = 0;
return;
}
bio->data = bio->data0 = (char *) data + n;
bio->offs = bio->offs0 = data;
bio->data_avail = maxdata - n;
bio->offs_avail = maxoffs;
bio->flags = 0;
}
static void *bio_alloc(struct binder_io *bio, size_t size)
{
size = (size + 3) & (~3);
if (size > bio->data_avail) {
bio->flags |= BIO_F_OVERFLOW;
return NULL;
} else {
void *ptr = bio->data;
bio->data += size;
bio->data_avail -= size;
return ptr;
}
}
void binder_done(struct binder_state *bs,
__unused struct binder_io *msg,
struct binder_io *reply)
{
struct {
uint32_t cmd;
uintptr_t buffer;
} __attribute__((packed)) data;
if (reply->flags & BIO_F_SHARED) {
data.cmd = BC_FREE_BUFFER;
data.buffer = (uintptr_t) reply->data0;
binder_write(bs, &data, sizeof(data));
reply->flags = 0;
}
}
static struct flat_binder_object *bio_alloc_obj(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = bio_alloc(bio, sizeof(*obj));
if (obj && bio->offs_avail) {
bio->offs_avail--;
*bio->offs++ = ((char*) obj) - ((char*) bio->data0);
return obj;
}
bio->flags |= BIO_F_OVERFLOW;
return NULL;
}
void bio_put_uint32(struct binder_io *bio, uint32_t n)
{
uint32_t *ptr = bio_alloc(bio, sizeof(n));
if (ptr)
*ptr = n;
}
void bio_put_obj(struct binder_io *bio, void *ptr)
{
struct flat_binder_object *obj;
obj = bio_alloc_obj(bio);
if (!obj)
return;
obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
obj->type = BINDER_TYPE_BINDER;
obj->binder = (uintptr_t)ptr;
obj->cookie = 0;
}
void bio_put_ref(struct binder_io *bio, uint32_t handle)
{
struct flat_binder_object *obj;
if (handle)
obj = bio_alloc_obj(bio);
else
obj = bio_alloc(bio, sizeof(*obj));
if (!obj)
return;
obj->flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
obj->type = BINDER_TYPE_HANDLE;
obj->handle = handle;
obj->cookie = 0;
}
void bio_put_string16(struct binder_io *bio, const uint16_t *str)
{
size_t len;
uint16_t *ptr;
if (!str) {
bio_put_uint32(bio, 0xffffffff);
return;
}
len = 0;
while (str[len]) len++;
if (len >= (MAX_BIO_SIZE / sizeof(uint16_t))) {
bio_put_uint32(bio, 0xffffffff);
return;
}
/* Note: The payload will carry 32bit size instead of size_t */
bio_put_uint32(bio, (uint32_t) len);
len = (len + 1) * sizeof(uint16_t);
ptr = bio_alloc(bio, len);
if (ptr)
memcpy(ptr, str, len);
}
void bio_put_string16_x(struct binder_io *bio, const char *_str)
{
unsigned char *str = (unsigned char*) _str;
size_t len;
uint16_t *ptr;
if (!str) {
bio_put_uint32(bio, 0xffffffff);
return;
}
len = strlen(_str);
if (len >= (MAX_BIO_SIZE / sizeof(uint16_t))) {
bio_put_uint32(bio, 0xffffffff);
return;
}
/* Note: The payload will carry 32bit size instead of size_t */
bio_put_uint32(bio, len);
ptr = bio_alloc(bio, (len + 1) * sizeof(uint16_t));
if (!ptr)
return;
while (*str)
*ptr++ = *str++;
*ptr++ = 0;
}
static void *bio_get(struct binder_io *bio, size_t size)
{
size = (size + 3) & (~3);
if (bio->data_avail < size){
bio->data_avail = 0;
bio->flags |= BIO_F_OVERFLOW;
return NULL;
} else {
void *ptr = bio->data;
bio->data += size;
bio->data_avail -= size;
return ptr;
}
}
uint32_t bio_get_uint32(struct binder_io *bio)
{
uint32_t *ptr = bio_get(bio, sizeof(*ptr));
return ptr ? *ptr : 0;
}
uint16_t *bio_get_string16(struct binder_io *bio, size_t *sz)
{
size_t len;
/* Note: The payload will carry 32bit size instead of size_t */
len = (size_t) bio_get_uint32(bio);
if (sz)
*sz = len;
return bio_get(bio, (len + 1) * sizeof(uint16_t));
}
static struct flat_binder_object *_bio_get_obj(struct binder_io *bio)
{
size_t n;
size_t off = bio->data - bio->data0;
/* TODO: be smarter about this? */
for (n = 0; n < bio->offs_avail; n++) {
if (bio->offs[n] == off)
return bio_get(bio, sizeof(struct flat_binder_object));
}
bio->data_avail = 0;
bio->flags |= BIO_F_OVERFLOW;
return NULL;
}
uint32_t bio_get_ref(struct binder_io *bio)
{
struct flat_binder_object *obj;
obj = _bio_get_obj(bio);
if (!obj)
return 0;
if (obj->type == BINDER_TYPE_HANDLE)
return obj->handle;
return 0;
}

73
04_day/binder_2/binder.h Normal file
View File

@ -0,0 +1,73 @@
/* Copyright 2008 The Android Open Source Project
*/
#ifndef _BINDER_H_
#define _BINDER_H_
#include <sys/ioctl.h>
#include <linux/android/binder.h>
struct binder_state;
struct binder_io
{
char *data; /* pointer to read/write from */
binder_size_t *offs; /* array of offsets */
size_t data_avail; /* bytes available in data buffer */
size_t offs_avail; /* entries available in offsets array */
char *data0; /* start of data buffer */
binder_size_t *offs0; /* start of offsets buffer */
uint32_t flags;
uint32_t unused;
};
struct binder_death {
void (*func)(struct binder_state *bs, void *ptr);
void *ptr;
};
/* the one magic handle */
#define BINDER_SERVICE_MANAGER 0U
#define SVC_MGR_NAME "android.os.IServiceManager"
enum {
/* Must match definitions in IBinder.h and IServiceManager.h */
PING_TRANSACTION = B_PACK_CHARS('_','P','N','G'),
SVC_MGR_GET_SERVICE = 1,
SVC_MGR_CHECK_SERVICE,
SVC_MGR_ADD_SERVICE,
SVC_MGR_LIST_SERVICES,
};
typedef int (*binder_handler)(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply);
struct binder_state *binder_open(const char* driver, size_t mapsize);
void binder_close(struct binder_state *bs);
/* initiate a blocking binder call
* - returns zero on success
*/
int binder_call(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply,
uint32_t target, uint32_t code);
/* release any state associate with the binder_io
* - call once any necessary data has been extracted from the
* binder_io after binder_call() returns
* - can safely be called even if binder_call() fails
*/
void binder_done(struct binder_state *bs,
struct binder_io *msg, struct binder_io *reply);
/* manipulate strong references */
void binder_acquire(struct binder_state *bs, uint32_t target);
void binder_release(struct binder_state *bs, uint32_t target);
void binder_link_to_death(struct binder_state *bs, uint32_t target, struct binder_death *death);
void binder_loop(struct binder_state *bs, binder_handler func);
int binder_become_context_manager(struct binder_state *bs);
/* allocate a binder_io, providing a stack-allocated working
* buffer, size of the working buffer, and how many object
* offset entries to reserve from the buffer
*/
void bio_init(struct binder_io *bio, void *data,
size_t maxdata, size_t maxobjects);
void bio_put_obj(struct binder_io *bio, void *ptr);
void bio_put_ref(struct binder_io *bio, uint32_t handle);
void bio_put_uint32(struct binder_io *bio, uint32_t n);
void bio_put_string16(struct binder_io *bio, const uint16_t *str);
void bio_put_string16_x(struct binder_io *bio, const char *_str);
uint32_t bio_get_uint32(struct binder_io *bio);
uint16_t *bio_get_string16(struct binder_io *bio, size_t *sz);
uint32_t bio_get_ref(struct binder_io *bio);
#endif

55
04_day/binder_2/my_client.c Normal file
View File

@ -0,0 +1,55 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
return 0;
handle = bio_get_ref(&reply);
if (handle)
binder_acquire(bs, handle);
binder_done(bs, &msg, &reply);
return handle;
}
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
uint32_t handle;
unsigned iodata[512/4];
struct binder_io msg, reply;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
handle = svcmgr_lookup(bs, svcmgr, argv[argc-1]);
fprintf(stderr,"lookup(%s) = %x\n", argv[argc-1], handle);
bio_init(&msg, iodata, sizeof(iodata), 4);
binder_call(bs, &msg, &reply, handle, 1);
binder_call(bs, &msg, &reply, handle, 2);
return 0;
}

99
04_day/binder_2/my_server.c Normal file
View File

@ -0,0 +1,99 @@
/* Copyright 2008 The Android Open Source Project
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "binder.h"
typedef struct
{
void (*on)(void);
void (*off)(void);
} LED_INFO;
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
int status;
unsigned iodata[512/4];
struct binder_io msg, reply;
bio_init(&msg, iodata, sizeof(iodata), 4);
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, SVC_MGR_NAME);
bio_put_string16_x(&msg, name);
bio_put_obj(&msg, ptr);
if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
return -1;
status = bio_get_uint32(&reply);
binder_done(bs, &msg, &reply);
return status;
}
int my_handler(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply)
{
printf("my_handler %p %p %p %p\n", bs, txn, msg, reply);
LED_INFO *Led = (LED_INFO*)txn->target.ptr;
switch(txn->code) {
case 1:
{
Led->on();
return 0;
}
case 2:
{
Led->off();
return 0;
}
default:
printf("unknown code %d\n", txn->code);
return -1;
}
bio_put_uint32(reply, 0);
return 0;
}
void ledOn(void)
{
printf("Server : ledOn\n");
}
void ledOff(void)
{
printf("Server : ledOff\n");
}
int main(int argc, char **argv)
{
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
LED_INFO *Led;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
Led = (LED_INFO*)malloc( sizeof(LED_INFO) );
Led->on = ledOn;
Led->off = ledOff;
printf("Server : &token = %p\n", Led );
svcmgr_publish(bs, svcmgr, argv[argc-1], Led);
binder_loop(bs, my_handler);
return 0;
}

15
04_day/binder_3/Android.bp Normal file
View File

@ -0,0 +1,15 @@
cc_binary {
name: "my_server_cpp_1",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_server.cpp",
],
}
cc_binary {
name: "my_client_cpp_1",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_client.cpp",
],
}

54
04_day/binder_3/ProcessState.cpp Normal file
View File

@ -0,0 +1,54 @@
#if 1
#include <stdio.h>
class ProcessState
{
static ProcessState *gProcess;
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
public:
static ProcessState *self()
{
if( gProcess == 0 )
gProcess = new ProcessState;
return gProcess;
}
~ProcessState()
{
printf("close(fd)\n");
}
};
ProcessState *ProcessState::gProcess = 0;
int main()
{
ProcessState *p1 = ProcessState::self();
ProcessState *p2 = ProcessState::self();
//ProcessState process;
return 0;
}
#endif
#if 0
#include <stdio.h>
class ProcessState
{
public:
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
~ProcessState()
{
printf("close(fd)\n");
}
};
int main()
{
ProcessState p1;
ProcessState p2;
return 0;
}
#endif

22
04_day/binder_3/my_client.cpp Normal file
View File

@ -0,0 +1,22 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sp<IBinder> binder = sm->getService( String16("led.service") );
Parcel data, reply;
binder->transact(1, data, &reply);
return 0;
}

38
04_day/binder_3/my_server.cpp Normal file
View File

@ -0,0 +1,38 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
using namespace android;
class LedService : public BBinder
{
public:
status_t onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case 1:
printf("LedService::LED_ON\n");
return NO_ERROR;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
};
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sm->addService( String16("led.service"), new LedService );
IPCThreadState::self()->joinThreadPool();
return 0;
}

16
04_day/binder_4/Android.bp Normal file
View File

@ -0,0 +1,16 @@
cc_binary {
name: "my_server_cpp_2",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_server.cpp",
],
}
cc_binary {
name: "my_client_cpp_2",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_client.cpp",
"ILedService.cpp",
],
}

31
04_day/binder_4/ILedService.cpp Normal file
View File

@ -0,0 +1,31 @@
#define LOG_TAG "LedService"
#include "ILedService.h"
#include <binder/IPCThreadState.h>
#include <binder/Parcel.h>
#include <unistd.h>
namespace android {
// ----------------------------------------------------------------------
class BpLedService : public BpInterface<ILedService>
{
public:
explicit BpLedService(const sp<IBinder>& impl)
: BpInterface<ILedService>(impl)
{
}
virtual void ledOn(void)
{
printf("BpLedService::ledOn()\n");
Parcel data, reply;
remote()->transact(LED_ON, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(LedService, "android.os.ILedService");
}; // namespace android

26
04_day/binder_4/ILedService.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef ANDROID_ILED_SERVICE_H
#define ANDROID_ILED_SERVICE_H
#include <binder/IInterface.h>
#include <utils/String16.h>
namespace android {
// ----------------------------------------------------------------------
class ILedService : public IInterface
{
public:
DECLARE_META_INTERFACE(LedService)
virtual void ledOn() = 0;
enum {
LED_ON = IBinder::FIRST_CALL_TRANSACTION
};
};
}; // namespace android
#endif // ANDROID_ISERVICE_MANAGER_H

54
04_day/binder_4/ProcessState.cpp Normal file
View File

@ -0,0 +1,54 @@
#if 1
#include <stdio.h>
class ProcessState
{
static ProcessState *gProcess;
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
public:
static ProcessState *self()
{
if( gProcess == 0 )
gProcess = new ProcessState;
return gProcess;
}
~ProcessState()
{
printf("close(fd)\n");
}
};
ProcessState *ProcessState::gProcess = 0;
int main()
{
ProcessState *p1 = ProcessState::self();
ProcessState *p2 = ProcessState::self();
//ProcessState process;
return 0;
}
#endif
#if 0
#include <stdio.h>
class ProcessState
{
public:
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
~ProcessState()
{
printf("close(fd)\n");
}
};
int main()
{
ProcessState p1;
ProcessState p2;
return 0;
}
#endif

23
04_day/binder_4/my_client.cpp Normal file
View File

@ -0,0 +1,23 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include "ILedService.h"
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sp<IBinder> binder = sm->getService( String16("led.service") );
sp<ILedService> led = interface_cast<ILedService>( binder );
led->ledOn();
return 0;
}

38
04_day/binder_4/my_server.cpp Normal file
View File

@ -0,0 +1,38 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
using namespace android;
class LedService : public BBinder
{
public:
status_t onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case 1:
printf("LedService::LED_ON\n");
return NO_ERROR;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
};
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sm->addService( String16("led.service"), new LedService );
IPCThreadState::self()->joinThreadPool();
return 0;
}

18
04_day/binder_5/Android.bp Normal file
View File

@ -0,0 +1,18 @@
cc_binary {
name: "my_server_cpp_3",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_server.cpp",
"ILedService.cpp",
"LedService.cpp",
],
}
cc_binary {
name: "my_client_cpp_3",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_client.cpp",
"ILedService.cpp",
],
}

46
04_day/binder_5/ILedService.cpp Normal file
View File

@ -0,0 +1,46 @@
#define LOG_TAG "LedService"
#include "ILedService.h"
#include <binder/IPCThreadState.h>
#include <binder/Parcel.h>
#include <unistd.h>
namespace android {
// ----------------------------------------------------------------------
class BpLedService : public BpInterface<ILedService>
{
public:
explicit BpLedService(const sp<IBinder>& impl)
: BpInterface<ILedService>(impl)
{
}
virtual void ledOn(void)
{
printf("BpLedService::ledOn()\n");
Parcel data, reply;
remote()->transact(LED_ON, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(LedService, "android.os.ILedService");
// ----------------------------------------------------------------------
status_t BnLedService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case LED_ON: {
ledOn();
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// ----------------------------------------------------------------------
}; // namespace android

41
04_day/binder_5/ILedService.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef ANDROID_ILED_SERVICE_H
#define ANDROID_ILED_SERVICE_H
#include <binder/IInterface.h>
#include <utils/String16.h>
namespace android {
// ----------------------------------------------------------------------
class ILedService : public IInterface
{
public:
DECLARE_META_INTERFACE(LedService)
virtual void ledOn() = 0;
enum {
LED_ON = IBinder::FIRST_CALL_TRANSACTION
};
};
// ----------------------------------------------------------------------
class BnLedService : public BnInterface<ILedService>
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_ISERVICE_MANAGER_H

10
04_day/binder_5/LedService.cpp Normal file
View File

@ -0,0 +1,10 @@
#include "LedService.h"
#include <stdio.h>
namespace android
{
void LedService::ledOn(void)
{
printf("LedService::ledOn()\n");
}
};

13
04_day/binder_5/LedService.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef ANDROID_LED_SERVICE_H
#define ANDROID_LED_SERVICE_H
#include "ILedService.h"
namespace android {
class LedService : public BnLedService
{
public :
void ledOn(void);
};
};
#endif

54
04_day/binder_5/ProcessState.cpp Normal file
View File

@ -0,0 +1,54 @@
#if 1
#include <stdio.h>
class ProcessState
{
static ProcessState *gProcess;
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
public:
static ProcessState *self()
{
if( gProcess == 0 )
gProcess = new ProcessState;
return gProcess;
}
~ProcessState()
{
printf("close(fd)\n");
}
};
ProcessState *ProcessState::gProcess = 0;
int main()
{
ProcessState *p1 = ProcessState::self();
ProcessState *p2 = ProcessState::self();
//ProcessState process;
return 0;
}
#endif
#if 0
#include <stdio.h>
class ProcessState
{
public:
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
~ProcessState()
{
printf("close(fd)\n");
}
};
int main()
{
ProcessState p1;
ProcessState p2;
return 0;
}
#endif

23
04_day/binder_5/my_client.cpp Normal file
View File

@ -0,0 +1,23 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include "ILedService.h"
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sp<IBinder> binder = sm->getService( String16("led.service") );
sp<ILedService> led = interface_cast<ILedService>( binder );
led->ledOn();
return 0;
}

22
04_day/binder_5/my_server.cpp Normal file
View File

@ -0,0 +1,22 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include "LedService.h"
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sm->addService( String16("led.service"), new LedService );
IPCThreadState::self()->joinThreadPool();
return 0;
}

21
04_day/binder_6/Android.bp Normal file
View File

@ -0,0 +1,21 @@
cc_binary {
name: "my_server_cpp_4",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_server.cpp",
"ILedService.cpp",
"LedService.cpp",
"ILedClient.cpp",
],
}
cc_binary {
name: "my_client_cpp_4",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"my_client.cpp",
"ILedService.cpp",
"ILedClient.cpp",
"Led.cpp",
],
}

49
04_day/binder_6/ILedClient.cpp Normal file
View File

@ -0,0 +1,49 @@
#define LOG_TAG "LedClient"
#include "ILedClient.h"
#include <binder/IPCThreadState.h>
#include <binder/Parcel.h>
#include <unistd.h>
namespace android {
// ----------------------------------------------------------------------
class BpLedClient : public BpInterface<ILedClient>
{
public:
explicit BpLedClient(const sp<IBinder>& impl)
: BpInterface<ILedClient>(impl)
{
}
virtual void dataCallback(int ratio)
{
printf("BpLedClient::dataCallback()\n");
Parcel data, reply;
data.writeInt32(ratio);
remote()->transact(DATA_CALLBACK, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(LedClient, "android.os.ILedClient");
// ----------------------------------------------------------------------
status_t BnLedClient::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case DATA_CALLBACK: {
int temp;
temp = data.readInt32();
dataCallback(temp);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// ----------------------------------------------------------------------
}; // namespace android

41
04_day/binder_6/ILedClient.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef ANDROID_ILED_CLIENT_H
#define ANDROID_ILED_CLIENT_H
#include <binder/IInterface.h>
#include <utils/String16.h>
namespace android {
// ----------------------------------------------------------------------
class ILedClient : public IInterface
{
public:
DECLARE_META_INTERFACE(LedClient)
virtual void dataCallback (int ratio) = 0;
enum {
DATA_CALLBACK = IBinder::FIRST_CALL_TRANSACTION
};
};
// ----------------------------------------------------------------------
class BnLedClient : public BnInterface<ILedClient>
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_ISERVICE_MANAGER_H

49
04_day/binder_6/ILedService.cpp Normal file
View File

@ -0,0 +1,49 @@
#define LOG_TAG "LedService"
#include "ILedService.h"
#include <binder/IPCThreadState.h>
#include <binder/Parcel.h>
#include <unistd.h>
namespace android {
// ----------------------------------------------------------------------
class BpLedService : public BpInterface<ILedService>
{
public:
explicit BpLedService(const sp<IBinder>& impl)
: BpInterface<ILedService>(impl)
{
}
virtual void connect(sp<ILedClient>& client)
{
printf("BpLedService::ledOn()\n");
Parcel data, reply;
data.writeStrongBinder(ILedClient::asBinder(client));
remote()->transact(CONNECT, data, &reply);
}
};
IMPLEMENT_META_INTERFACE(LedService, "android.os.ILedService");
// ----------------------------------------------------------------------
status_t BnLedService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case CONNECT: {
sp<ILedClient> client;
data.readStrongBinder(&client);
connect(client);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
// ----------------------------------------------------------------------
}; // namespace android

42
04_day/binder_6/ILedService.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef ANDROID_ILED_SERVICE_H
#define ANDROID_ILED_SERVICE_H
#include <binder/IInterface.h>
#include <utils/String16.h>
#include "ILedClient.h"
namespace android {
// ----------------------------------------------------------------------
class ILedService : public IInterface
{
public:
DECLARE_META_INTERFACE(LedService)
virtual void connect(sp<ILedClient>& client) = 0;
enum {
CONNECT = IBinder::FIRST_CALL_TRANSACTION
};
};
// ----------------------------------------------------------------------
class BnLedService : public BnInterface<ILedService>
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_ISERVICE_MANAGER_H

10
04_day/binder_6/Led.cpp Normal file
View File

@ -0,0 +1,10 @@
#include "Led.h"
#include <stdio.h>
namespace android
{
void Led::dataCallback(int ratio)
{
printf("Led::dataCallback(%d)\n", ratio);
}
};

13
04_day/binder_6/Led.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef ANDROID_LED_H
#define ANDROID_LED_H
#include "ILedClient.h"
namespace android {
class Led : public BnLedClient
{
public :
void dataCallback(int ratio);
};
};
#endif

11
04_day/binder_6/LedService.cpp Normal file
View File

@ -0,0 +1,11 @@
#include "LedService.h"
#include <stdio.h>
namespace android
{
void LedService::connect(sp<ILedClient>& client)
{
printf("LedService::ledOn()\n");
client->dataCallback(222);
}
};

13
04_day/binder_6/LedService.h Normal file
View File

@ -0,0 +1,13 @@
#ifndef ANDROID_LED_SERVICE_H
#define ANDROID_LED_SERVICE_H
#include "ILedService.h"
namespace android {
class LedService : public BnLedService
{
public :
void connect(sp<ILedClient>& client);
};
};
#endif

54
04_day/binder_6/ProcessState.cpp Normal file
View File

@ -0,0 +1,54 @@
#if 1
#include <stdio.h>
class ProcessState
{
static ProcessState *gProcess;
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
public:
static ProcessState *self()
{
if( gProcess == 0 )
gProcess = new ProcessState;
return gProcess;
}
~ProcessState()
{
printf("close(fd)\n");
}
};
ProcessState *ProcessState::gProcess = 0;
int main()
{
ProcessState *p1 = ProcessState::self();
ProcessState *p2 = ProcessState::self();
//ProcessState process;
return 0;
}
#endif
#if 0
#include <stdio.h>
class ProcessState
{
public:
ProcessState()
{
printf("fd=open(\"/dev/binder\", O_RDWR)\n");
}
~ProcessState()
{
printf("close(fd)\n");
}
};
int main()
{
ProcessState p1;
ProcessState p2;
return 0;
}
#endif

BIN
04_day/binder_6/a.out Normal file
View File

Binary file not shown.

27
04_day/binder_6/my_client.cpp Normal file
View File

@ -0,0 +1,27 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include "ILedService.h"
#include "Led.h"
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sp<IBinder> binder = sm->getService( String16("led.service") );
sp<ILedService> led = interface_cast<ILedService>( binder );
sp<ILedClient> client = new Led;
led->connect( client );
IPCThreadState::self()->joinThreadPool();
return 0;
}

22
04_day/binder_6/my_server.cpp Normal file
View File

@ -0,0 +1,22 @@
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <binder/Binder.h>
#include <binder/IPCThreadState.h>
#include <utils/String16.h>
#include "LedService.h"
using namespace android;
int main()
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm(defaultServiceManager());
sm->addService( String16("led.service"), new LedService );
IPCThreadState::self()->joinThreadPool();
return 0;
}

43
04_day/binder_6/thread.cpp Normal file
View File

@ -0,0 +1,43 @@
#if 1
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int global=6;
void *foo(void *data)
{
printf("child , global=%d, local=%d\n", ++global, ++*(int*)data);
return 0;
}
int main()
{
int local=10;
pthread_t thread;
pthread_create(&thread, 0, foo, &local );
//foo(&local);
pthread_join( thread, 0 );
printf("parent , global=%d, local=%d\n", ++global, local);
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int global=6;
int main()
{
pid_t pid;
pid = fork();
if( pid == 0 )
{
printf("child, global=%d\n", ++global);
exit(0);
}
wait(0);
printf("parent, global=%d\n", global);
return 0;
}
#endif

7
04_day/sp/Android.bp Normal file
View File

@ -0,0 +1,7 @@
cc_binary {
name: "my_wp",
shared_libs: ["liblog", "libutils"],
srcs: [
"wp_1.cpp",
],
}

BIN
04_day/sp/a.out Normal file
View File

Binary file not shown.

409
04_day/sp/sp.cpp Normal file
View File

@ -0,0 +1,409 @@
#if 1
#include <stdio.h>
class RefBase
{
int mRefs;
public:
RefBase():mRefs(0) { printf("RefBase::RefBase()\n"); }
virtual ~RefBase() { printf("RefBase::~RefBase()\n"); }
void incStrong() {
printf("RefBase::incStrong() : mRefs=%d\n", ++mRefs);
}
void decStrong()
{
--mRefs;
printf("RefBase::decStrong() : mRefs=%d\n", mRefs);
if( mRefs == 0 )
delete this;
}
};
class AAA : public virtual RefBase
{
public:
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
template < typename T >
class sp
{
T *mPtr;
public:
sp( T *ptr):mPtr(ptr) {
printf("sp::sp(T)\n");
mPtr->incStrong();
}
sp( const sp<T> &r ) : mPtr(r.mPtr) {
printf("sp::sp(sp<T>)\n");
mPtr->incStrong();
}
~sp() {
printf("sp::~sp()\n");
mPtr->decStrong();
}
T * operator->()
{
return mPtr;
}
T operator*()
{
return *mPtr;
}
};
int main()
{
{
sp<AAA> p1 = new AAA;
sp<AAA> p2 = p1;
p1->foo();
p2->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
int mRefs;
public:
AAA():mRefs(0) { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
void incStrong() {
printf("AAA::incStrong() : mRefs=%d\n", ++mRefs);
}
void decStrong()
{
--mRefs;
printf("AAA::decStrong() : mRefs=%d\n", mRefs);
if( mRefs == 0 )
delete this;
}
};
template < typename T >
class sp
{
T *mPtr;
public:
sp( T *ptr):mPtr(ptr) {
printf("sp::sp(T)\n");
mPtr->incStrong();
}
sp( const sp<T> &r ) : mPtr(r.mPtr) {
printf("sp::sp(sp<T>)\n");
mPtr->incStrong();
}
~sp() {
printf("sp::~sp()\n");
mPtr->decStrong();
}
T * operator->()
{
return mPtr;
}
T operator*()
{
return *mPtr;
}
};
int main()
{
{
sp<AAA> p1 = new AAA;
sp<AAA> p2 = p1;
p1->foo();
p2->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
template < typename T >
class sp
{
T *mPtr;
static int mRefs;
public:
sp( T *ptr):mPtr(ptr) {
mRefs=1;
printf("sp::sp(T), mRefs=%d\n", mRefs);
}
sp( const sp<T> &r ) {
mRefs++;
printf("sp::sp(sp<T>), mRefs=%d\n", mRefs);
}
~sp() {
printf("sp::~sp()\n");
if( --mRefs == 0 )
delete mPtr;
}
T * operator->()
{
return mPtr;
}
T operator*()
{
return *mPtr;
}
};
template < typename T >
int sp<T>::mRefs = 0;
int main()
{
{
sp<AAA> p1 = new AAA;
sp<AAA> p2 = p1;
p1->foo();
p2->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
template < typename T >
class sp
{
T *mPtr;
public:
sp( T *ptr):mPtr(ptr) { printf("sp::sp()\n"); }
~sp() {
printf("sp::~sp()\n");
delete mPtr;
}
T * operator->()
{
return mPtr;
}
T operator*()
{
return *mPtr;
}
};
int main()
{
{
sp<AAA> p1 = new AAA;
sp<AAA> p2 = p1;
p1->foo();
p2->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
class BBB
{
public:
BBB() { printf("BBB::BBB()\n"); }
~BBB() { printf("BBB::~BBB()\n"); }
void foo() { printf("BBB::foo()\n"); }
};
template < typename T >
class sp
{
T *mPtr;
public:
sp( T *ptr):mPtr(ptr) { printf("sp::sp()\n"); }
~sp() {
printf("sp::~sp()\n");
delete mPtr;
}
T * operator->()
{
return mPtr;
}
T operator*()
{
return *mPtr;
}
};
int main()
{
{
sp<AAA> pa = new AAA;
pa->foo();
sp<BBB> pb = new BBB;
pb->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
class sp
{
AAA *mPtr;
public:
sp( AAA *ptr):mPtr(ptr) { printf("sp::sp()\n"); }
~sp() {
printf("sp::~sp()\n");
delete mPtr;
}
AAA * operator->()
{
return mPtr;
}
AAA operator*()
{
return *mPtr;
}
};
int main()
{
{
sp pa = new AAA;
pa->foo(); // pa.operator->()->foo();
(*pa).foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
class sp
{
AAA *mPtr;
public:
sp( AAA *ptr):mPtr(ptr) { printf("sp::sp()\n"); }
~sp() {
printf("sp::~sp()\n");
delete mPtr;
}
};
int main()
{
{
//AAA* pa = new AAA;
//pa->foo();
sp pa = new AAA;
pa->foo(); // pa.operator->()->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
};
int main()
{
AAA *pa = new AAA;
//...
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
};
int main()
{
AAA *pa = new AAA;
delete pa;
//...
return 0;
}
#endif
#if 0
#include <stdio.h>
class AAA
{
public:
AAA() { printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
};
int main()
{
AAA aaa;
return 0;
}
#endif

82
04_day/sp/sp_1.cpp Normal file
View File

@ -0,0 +1,82 @@
#if 1
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA;
class BBB;
class AAA : public virtual RefBase
{
public:
wp<BBB> pb;
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
class BBB : public virtual RefBase
{
public:
wp<AAA> pa;
BBB(){ printf("BBB::BBB()\n"); }
~BBB() { printf("BBB::~BBB()\n"); }
void foo() { printf("BBB::foo()\n"); }
};
int main()
{
{
sp<AAA> p1 = new AAA;
sp<BBB> p2 = new BBB;
p1->pb = p2;
p2->pa = p1;
}
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA;
class BBB;
class AAA : public virtual RefBase
{
public:
sp<BBB> pb;
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
class BBB : public virtual RefBase
{
public:
sp<AAA> pa;
BBB(){ printf("BBB::BBB()\n"); }
~BBB() { printf("BBB::~BBB()\n"); }
void foo() { printf("BBB::foo()\n"); }
};
int main()
{
{
sp<AAA> p1 = new AAA;
sp<BBB> p2 = new BBB;
p1->pb = p2;
p2->pa = p1;
}
return 0;
}
#endif

119
04_day/sp/wp_1.cpp Normal file
View File

@ -0,0 +1,119 @@
#if 1
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA : public virtual RefBase
{
int data;
public:
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() // void foo( AAA *this )
{
data = 10; // this->data = 10; => (*0).data = 10;
printf("AAA::foo()\n");
}
};
int main()
{
//((AAA*)0)->foo(); // AAA::foo(0);
{
wp<AAA> p1 = new AAA;
{
sp<AAA> p2 = p1.promote();
p2->foo();
}
printf("step 1.\n");
if( p1.promote() != 0 )
p1.promote()->foo();
else
printf("객체는 이미 소멸됨\n");
}
printf("step 2.\n");
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA : public virtual RefBase
{
public:
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
int main()
{
{
wp<AAA> p1 = new AAA;
sp<AAA> p2 = p1.promote();
p2->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA : public virtual RefBase
{
public:
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
int main()
{
{
sp<AAA> p1 = new AAA;
wp<AAA> p2 = p1;
p1->foo();
}
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
using namespace android;
class AAA : public virtual RefBase
{
public:
AAA(){ printf("AAA::AAA()\n"); }
~AAA() { printf("AAA::~AAA()\n"); }
void foo() { printf("AAA::foo()\n"); }
};
int main()
{
{
wp<AAA> pa = new AAA;
pa.promote()->foo();
}
return 0;
}
#endif

BIN
04_day/thread/.Thread.cpp.swp Normal file
View File

Binary file not shown.

8
04_day/thread/Android.bp Normal file
View File

@ -0,0 +1,8 @@
cc_binary {
name: "my_thread_1",
shared_libs: ["liblog", "libutils", "libbinder"],
srcs: [
"Thread.cpp",
],
}

261
04_day/thread/Thread.cpp Normal file
View File

@ -0,0 +1,261 @@
#if 1
#include <stdio.h>
#include <utils/Thread.h>
#include <utils/StrongPointer.h>
using namespace android;
//--------------------------------------------------------
class MyThread : public Thread
{
int volume;
public:
bool threadLoop(void)
{
volume=100;
printf("MyThread::threadLoop(), volume=%d\n", volume);
return false;
}
};
int main()
{
sp<Thread> thread = new MyThread;
thread->run("MyThread");
thread->join();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
class Thread
{
pthread_t thread;
public:
virtual void foo(void) = 0;
static void * _foo(void *data )
{
Thread *self = (Thread*)data;
self->foo();
return 0;
}
void run()
{
pthread_create( &thread, 0, _foo, this );
}
void join()
{
pthread_join( thread, 0 );
}
};
//--------------------------------------------------------
class MyThread : public Thread
{
int volume;
public:
void foo(void)
{
volume=100;
printf("foo(), volume=%d\n", volume);
}
};
int main()
{
Thread *thread = new MyThread;
thread->run();
thread->join();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
class Thread
{
pthread_t thread;
int volume;
public:
void foo(void)
{
volume=100;
printf("foo(), volume=%d\n", volume);
}
static void * _foo(void *data )
{
Thread *self = (Thread*)data;
self->foo();
return 0;
}
void run()
{
pthread_create( &thread, 0, _foo, this );
}
void join()
{
pthread_join( thread, 0 );
}
};
//--------------------------------------------------------
int main()
{
Thread *thread = new Thread;
thread->run();
thread->join();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
class Thread
{
pthread_t thread;
int volume;
public:
static void * foo(void *data )
{
printf("foo()\n");
volume=100;
return 0;
}
void run()
{
pthread_create( &thread, 0, foo, 0 );
}
void join()
{
pthread_join( thread, 0 );
}
};
//--------------------------------------------------------
int main()
{
Thread *thread = new Thread;
thread->run();
thread->join();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
class AAA
{
int data;
public:
void set_data( int _data )
{
data = _data;
}
static void foo(void) // AAA::foo()
{
set_data(10); // set_data(this, 10);
printf("AAA::foo()\n");
}
};
//--------------------------------------------------------
int main()
{
void (*p)() = &AAA::foo;
(*p)(); // (*p)()
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
class AAA
{
public:
void foo(void) // AAA::foo(AAA *this)
{
printf("AAA::foo()\n");
}
};
//--------------------------------------------------------
int main()
{
//AAA aaa;
//aaa.foo(); // AAA::foo(&aaa);
AAA aaa;
void (AAA::*p)() = &AAA::foo;
(aaa.*p)(); // (*p)(&aaa)
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
void foo(void)
{
printf("foo()\n");
}
//--------------------------------------------------------
int main()
{
void (*p)(void) = foo;
p();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
void * foo(void *data )
{
printf("foo()\n");
return 0;
}
class Thread
{
pthread_t thread;
public:
void run()
{
pthread_create( &thread, 0, foo, 0 );
}
void join()
{
pthread_join( thread, 0 );
}
};
//--------------------------------------------------------
int main()
{
Thread *thread = new Thread;
thread->run();
thread->join();
return 0;
}
#endif
#if 0
#include <stdio.h>
#include <pthread.h>
void * foo(void *data )
{
printf("foo()\n");
return 0;
}
int main()
{
pthread_t thread;
pthread_create( &thread, 0, foo, 0 );
pthread_join( thread, 0 );
return 0;
}
#endif

BIN
04_day/thread/a.out Normal file
View File

Binary file not shown.