Android4.4 property機制學習

引言

本文借鑒自鄧平凡著《深入理解android卷I》第三章：【深入理解init】3.2.4小節：【屬性服務】，以及《深入講解Android Property機制》，僅供記錄學習使用，Android版本4.4 kitkak，

Android平臺的property service（屬性服務）機制，類似于windows中的注冊表，通常，系統或應用會將一些屬性以鍵值對的形式存盤在注冊表中，使得系統重啟或者應用重啟后，能夠根據之前注冊表中的設定進行初始化系統或應用，

1、Property初始化

property屬性的相關代碼可以在/system/core/init目錄下找到，首先是在init.c檔案的main函式中可以看到幾個和property相關的陳述句（省略了其他無關代碼）：

//  kitkak/system/core/init/init.c

int main(int argc, char **argv)
{
    int property_set_fd_init = 0;
    bool is_charger = false;

    property_init();

    is_charger = !strcmp(bootmode, "charger");

    INFO("property init\n");
    if (!is_charger)
        property_load_boot_defaults();
    …………
    queue_builtin_action(property_service_init_action, "property_service_init");

        /* run all property triggers based on current state of the properties */
    queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");

    for(;;) {
        int nr, i, timeout = -1;

        execute_one_command();
        restart_processes();

        if (!property_set_fd_init && get_property_set_fd() > 0) {
            ufds[fd_count].fd = get_property_set_fd();
            ufds[fd_count].events = POLLIN;
            ufds[fd_count].revents = 0;
            fd_count++;
            property_set_fd_init = 1;
        }
        …………
        for (i = 0; i < fd_count; i++) {
            if (ufds[i].revents == POLLIN) {
                if (ufds[i].fd == get_property_set_fd())
                    handle_property_set_fd();
                else if (ufds[i].fd == get_keychord_fd())
                    handle_keychord();
                else if (ufds[i].fd == get_signal_fd())
                    handle_signal();
            }
        }
    }

    return 0;
}

首先來看property_init()函式：

// kitkat/system/core/init/property_service.c

void property_init(void)
{
    init_property_area();
}

// kitkat/system/core/init/property_service.c

static int init_property_area(void)
{
    if (property_area_inited) //初始化部分：static int property_area_inited = 0;
        return -1;

    if(__system_property_area_init())
        return -1;

    if(init_workspace(&pa_workspace, 0))
        return -1;

    fcntl(pa_workspace.fd, F_SETFD, FD_CLOEXEC);

    property_area_inited = 1;
    return 0;
}

__system_property_area_init()函式是bionic c庫中的函式，其位于：/bionic/libc/bionic/system_properties.c:

//  kitkat/bionic/libc/bionic/system_properties.c

int __system_property_area_init()
{
    return map_prop_area_rw();
}

//  kitkat/bionic/libc/bionic/system_properties.c

struct prop_area {
    unsigned bytes_used;
    unsigned volatile serial;
    unsigned magic;
    unsigned version;
    unsigned reserved[28];
    char data[0];
};

typedef struct prop_area prop_area;

…………

prop_area *__system_property_area__ = NULL;

// kitkat\bionic\libc\include\sys\_system_properties.h

#define PROP_FILENAME "/dev/__properties__"


//  kitkat\bionic/libc/bionic/system_properties.c

static char property_filename[PATH_MAX] = PROP_FILENAME; 

// kitkat\bionic\libc\bionic\system_properties.c

static int map_prop_area_rw()
{
    prop_area *pa;
    int fd;
    int ret;

    /* dev is a tmpfs that we can use to carve a shared workspace
     * out of, so let's do that...
     */
    fd = open(property_filename, O_RDWR | O_CREAT | O_NOFOLLOW | O_CLOEXEC |
            O_EXCL, 0444);
    if (fd < 0) {
        if (errno == EACCES) {    //open函式所打開的檔案不符合所要求測驗的權限
            /* for consistency with the case where the process has already
             * mapped the page in and segfaults when trying to write to it
             */
            abort();
        }
        return -1;
    }

    ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
    if (ret < 0)
        goto out;

    if (ftruncate(fd, PA_SIZE) < 0)
        goto out;

    pa_size = PA_SIZE;
    pa_data_size = pa_size - sizeof(prop_area);
    compat_mode = false;

    pa = mmap(NULL, pa_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(pa == MAP_FAILED)
        goto out;

    memset(pa, 0, pa_size);
    pa->magic = PROP_AREA_MAGIC;
    pa->version = PROP_AREA_VERSION;
    /* reserve root node */
    pa->bytes_used = sizeof(prop_bt);

    /* plug into the lib property services */
    __system_property_area__ = pa;

    close(fd);
    return 0;

out:
    close(fd);
    return -1;
}

__system_property_area_init()函式輾轉呼叫map_prop_area_rw()函式，可以看到其首先通過open函式在/dev目錄下打開了一個檔案：__properties__，open函式的第三個八進制引數0444表示該檔案的權限為：-r--r--r--，第二個引數意義如下：

• O_RDWR：讀寫打開；
• O_CREAT：若欲打開的檔案不存在則自動建立該檔案，使用該選項時，需要第三個引數mode，用來指定新檔案的訪問權限位（對應上面的0444）；
• O_EXCL：如果O_CREAT 也被設定，此指令會去檢查檔案是否存在，檔案若不存在則建立該檔案，否則將導致打開檔案錯誤， 此外, 若O_CREAT 與O_EXCL 同時設定，并且欲打開的檔案為符號鏈接，則會打開檔案失敗；
• O_NOFOLLOW：如果引數pathname 所指的檔案為一符號連接，則會令打開檔案失敗；
• O_CLOEXEC：在行程執行exec系統呼叫時關閉此打開的檔案描述符（原子操作），防止父行程泄露打開的檔案給子行程，即便子行程沒有相應權限；

函式fcntl(fd, F_SETFD, FD_CLOEXEC)的作用是將檔案描述符close-on-exec標志設定為第三個引數的最后一位，而函式ftruncate(fd, PA_SIZE)會將引數fd指定的檔案大小改為引數PA_SIZE所指定的大小：

// kitkat\bionic\libc\include\sys\_system_properties.h

#define PA_SIZE         (128 * 1024)

接下來便是mmap函式，其主要功能是將檔案映射進記憶體，這里將檔案映射進記憶體，用于后續對__prooerties__檔案進行記憶體共享，該函式原型為：void* mmap(void* start, size_t length, int prot, int flags, int fd, off_t offset)；

1、引數start：指向欲映射的記憶體起始地址，通常設為 NULL，代表讓系統自動選定地址，映射成功后回傳該地址；

2、引數length：代表將檔案中多大的部分映射到記憶體；

3、引數prot：映射區域的保護方式，可以為以下這種方式的組合：

• PROT_EXEC：映射區域可被執行；
• PROT_READ：映射區域可被讀取；
• PROT_WRITE：映射區域可被寫入；
• PROT_NONE：映射區域不能存取；

4、引數flags：影響映射區域的各種特性，在呼叫mmap()時必須要指定MAP_SHARED 或MAP_PRIVATE；

• MAP_FIXED：如果引數start所指的地址無法成功建立映射時，則放棄映射，不對地址做修正，通常不鼓勵用此旗標；

• MAP_SHARED：對映射區域的寫入資料會復制回檔案內，而且允許其他映射該檔案的行程共享；

• MAP_PRIVATE：對映射區域的寫入操作會產生一個映射檔案的復制，即私人的“寫入時復制”（copy on write）對此區域作的任何修改都不會寫回原來的檔案內容；

• MAP_ANONYMOUS：建立匿名映射，此時會忽略引數fd，不涉及檔案，而且映射區域無法和其他行程共享；

• MAP_DENYWRITE：只允許對映射區域的寫入操作，其他對檔案直接寫入的操作將會被拒絕；

• MAP_LOCKED：將映射區域鎖定住，這表示該區域不會被置換（swap）；

5、引數fd：要映射到記憶體中的檔案描述符，如果使用匿名記憶體映射時，即flags中設定了MAP_ANONYMOUS，fd設為-1，有些系統不支持匿名記憶體映射，則可以使用fopen打開/dev/zero檔案，然后對該檔案進行映射，可以同樣達到匿名記憶體映射的效果，

6、引數offset：檔案映射的偏移量，通常設定為0，代表從檔案最前方開始對應，offset必須是分頁大小的整數倍，

7、回傳值：若映射成功則回傳映射區的記憶體起始地址，否則回傳MAP_FAILED(－1)，錯誤原因存于errno 中，

8、錯誤代碼：

• EBADF：引數fd 不是有效的檔案描述詞；

• EACCES：存取權限有誤，如果是MAP_PRIVATE 情況下檔案必須可讀，使用MAP_SHARED則要有PROT_WRITE以及該檔案要能寫入；

• EINVAL：引數start、length 或offset有一個不合法；

• EAGAIN：檔案被鎖住，或是有太多記憶體被鎖住；

• ENOMEM：記憶體不足；

根據代碼中的mmap函式的呼叫情況：pa = mmap(NULL, pa_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)；可以看出其將__prooerties__檔案的PA_SIZE大小以共享的方式映射進記憶體，映射區域擁有讀寫權限，映射記憶體的起始地址賦值給區域prop_area型別指標pa，后續代碼通過對指標pa所指向的實體進行賦值，并將pa指標賦值給全域變__system_property_area__ ，然后關閉檔案句柄，這個全域變數__system_property_area__作為指向屬性檔案所映射的記憶體空間起始位置的指標，擔負著后續其他程式呼叫獲取和設定屬性的主要物件的責任，文章后續還能見到，這里的映射程序借用別人的圖片來展示一下這個程序：

init_property_area函式中呼叫的__system_property_area_init()函式功能就此結束，接下來看后續呼叫的init_workspace函式，

// kitkat/system/core/init/property_service.c

typedef struct {
    size_t size;
    int fd;
} workspace;

static int init_workspace(workspace *w, size_t size)
{
    void *data;
    int fd = open(PROP_FILENAME, O_RDONLY | O_NOFOLLOW);
    if (fd < 0)
        return -1;

    w->size = size;
    w->fd = fd;
    return 0;
}

static workspace pa_workspace;

根據函式呼叫init_workspace(&pa_workspace, 0)和函式定義可以看出，其以只讀的方式再次打開檔案"/dev/__properties__"，這里把打開該檔案的句柄保存在靜態結構體實體pa_workspace的成員fd中，因為后續要用到，return之后回傳init_property_area函式，其后續將property_area_inited標志置為1，property_init函式結束，至此，函式property_init的呼叫鏈如下圖：

2、啟動Property

//  kitkak/system/core/init/init.c   

 INFO("property init\n");
    if (!is_charger)
        property_load_boot_defaults();
    …………
    queue_builtin_action(property_service_init_action, "property_service_init");

在init.c檔案的property_init函式之后，會看到上面的陳述句，這里的charger是關機充電下的系統模式，所以正常非關機充電情況下會執行property_load_boot_defaults()函式，該函式只有一個對/default.prop屬性檔案的加載陳述句 load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT)，后面會進行決議，而陳述句queue_builtin_action(property_service_init_action, "property_service_init")的作用就是把property_service_init_action函式處理為一個名為property_service_init的action（這個action同init行程啟動程序中，在init.rc檔案能看到的各種action相同），并將該action追加到init行程啟動程序中的action串列末尾，當順序執行或者觸發名為property_service_init的action時，就會執行property_service_init_action函式，該函式只有一個對start_property_service函式的呼叫陳述句，

// kitkat/system/core/init/property_service.c

void start_property_service(void)
{
    int fd;

    load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
    load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
    load_override_properties();
    /* Read persistent properties after all default values have been loaded. */
    load_persistent_properties();

    fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0);
    if(fd < 0) return;
    fcntl(fd, F_SETFD, FD_CLOEXEC);
    fcntl(fd, F_SETFL, O_NONBLOCK);

    listen(fd, 8);
    property_set_fd = fd;
}

start_property_service函式首先按照順序加載幾個默認屬性檔案，這幾個屬性檔案的路徑定義位于kitkat\bionic\libc\include\sys\_system_properties.h：

/*
** Rules:
**
** - there is only one writer, but many readers
** - prop_area.count will never decrease in value
** - once allocated, a prop_info's name will not change
** - once allocated, a prop_info's offset will not change
** - reading a value requires the following steps
**   1. serial = pi->serial
**   2. if SERIAL_DIRTY(serial), wait*, then goto 1
**   3. memcpy(local, pi->value, SERIAL_VALUE_LEN(serial) + 1)
**   4. if pi->serial != serial, goto 2
**
** - writing a value requires the following steps
**   1. pi->serial = pi->serial | 1
**   2. memcpy(pi->value, local_value, value_len)
**   3. pi->serial = (value_len << 24) | ((pi->serial + 1) & 0xffffff)
*/

#define PROP_PATH_RAMDISK_DEFAULT  "/default.prop"
#define PROP_PATH_SYSTEM_BUILD     "/system/build.prop"
#define PROP_PATH_SYSTEM_DEFAULT   "/system/default.prop"
#define PROP_PATH_LOCAL_OVERRIDE   "/data/local.prop"
#define PROP_PATH_FACTORY          "/factory/factory.prop"

// kitkat/system/core/init/property_service.c

static void load_properties_from_file(const char *fn)
{
    char *data;
    unsigned sz;

    data = read_file(fn, &sz);

    if(data != 0) {
        load_properties(data);
        free(data);
    }
}

// kitkat/system/core/init/property_service.c


/* reads a file, making sure it is terminated with \n \0 */
void *read_file(const char *fn, unsigned *_sz)
{
    char *data;
    int sz;
    int fd;
    struct stat sb;

    data = 0;
    fd = open(fn, O_RDONLY);
    if(fd < 0) return 0;

    // for security reasons, disallow world-writable
    // or group-writable files
    if (fstat(fd, &sb) < 0) {
        ERROR("fstat failed for '%s'\n", fn);
        goto oops;
    }
    if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
        ERROR("skipping insecure file '%s'\n", fn);
        goto oops;
    }

    sz = lseek(fd, 0, SEEK_END);
    if(sz < 0) goto oops;

    if(lseek(fd, 0, SEEK_SET) != 0) goto oops;

    data = (char*) malloc(sz + 2);
    if(data == 0) goto oops;

    if(read(fd, data, sz) != sz) goto oops;
    close(fd);
    data[sz] = '\n';
    data[sz+1] = 0;
    if(_sz) *_sz = sz;
    return data;

oops:
    close(fd);
    if(data != 0) free(data);
    return 0;
}

read_file函式中的結構體 stat和fstat參考《struct stat 操作 小結》可以看出，首先以只讀方式打開屬性檔案并回傳該檔案句柄，因為后面的fstat函式需要一個已打開的檔案句柄作為實參，把該檔案的狀態和屬性賦值到stat結構體當中去，

關于lseek函式，函式宣告：off_t lseek(int fd, off_t offset, int whence)；函式說明：每一個已打開的檔案都有一個讀寫位置，當打開檔案時通常其讀寫位置是指向檔案開頭，若是以附加的方式打開檔案(如O_APPEND)，則讀寫位置會指向檔案尾，當read()或write()時，讀寫位置會隨之增加，所以lseek()的作用就是用來控制該檔案的讀寫位置，當呼叫成功時則回傳目前的讀寫位置，也就是距離檔案開頭多少個位元組，若有錯誤則回傳-1，關于引數whence：

• SEEK_SET：引數offset 即為新的讀寫位置；
• SEEK_CUR：以目前的讀寫位置往后增加offset 個位移量；
• SEEK_END：將讀寫位置指向檔案尾后再增加offset 個位移量；
• 當whence 值為SEEK_CUR 或SEEK_END 時, 引數offet 允許負值的出現；

常用方式：

1. 欲將讀寫位置移到檔案開頭時：lseek(int fildes, 0, SEEK_SET)
2. 欲將讀寫位置移到檔案尾時：lseek(int fildes, 0, SEEK_END)
3. 想要取得目前檔案位置時：lseek(int fildes, 0, SEEK_CUR)

可以看出兩次執行lseek主要是為了檢測能否正常移動到檔案首部和尾部，而移動到尾部的時候回傳值sz即為該檔案大小，后面malloc申請了sz+2大小的空間，用于后面的read函式把檔案內容讀取出來，存盤到data所指向的記憶體空間中，并在末尾添加了'\n'和0，回傳指標data，

函式load_properties_from_file中，將屬性檔案內容讀取出來以后，便通過load_properties函式將屬性檔案中每行的key與value提取出來，執行property_set(key, value)將該屬性鍵值設定進屬性記憶體區域，property_set函式代碼如下：

// kitkat/system/core/init/property_service.c

int property_set(const char *name, const char *value)
{
    prop_info *pi;
    int ret;

    size_t namelen = strlen(name);
    size_t valuelen = strlen(value);

    if (!is_legal_property_name(name, namelen)) return -1;
    if (valuelen >= PROP_VALUE_MAX) return -1;

    pi = (prop_info*) __system_property_find(name);

    if(pi != 0) {
        /* ro.* properties may NEVER be modified once set */
        if(!strncmp(name, "ro.", 3)) return -1;

        __system_property_update(pi, value, valuelen);
    } else {
        ret = __system_property_add(name, namelen, value, valuelen);
        if (ret < 0) {
            ERROR("Failed to set '%s'='%s'\n", name, value);
            return ret;
        }
    }
    /* If name starts with "net." treat as a DNS property. */
    if (strncmp("net.", name, strlen("net.")) == 0)  {
        if (strcmp("net.change", name) == 0) {
            return 0;
        }
       /*
        * The 'net.change' property is a special property used track when any
        * 'net.*' property name is updated. It is _ONLY_ updated here. Its value
        * contains the last updated 'net.*' property.
        */
        property_set("net.change", name);
    } else if (persistent_properties_loaded &&
            strncmp("persist.", name, strlen("persist.")) == 0) {
        /*
         * Don't write properties to disk until after we have read all default properties
         * to prevent them from being overwritten by default values.
         */
        write_persistent_property(name, value);
    } else if (strcmp("selinux.reload_policy", name) == 0 &&
               strcmp("1", value) == 0) {
        selinux_reload_policy();
    }
    property_changed(name, value);
    return 0;
}

其首先通過is_legal_property_name()函式，判斷傳入的屬性名稱是否合法：

// kitkat/system/core/init/property_service.c

static bool is_legal_property_name(const char* name, size_t namelen)
{
    size_t i;
    bool previous_was_dot = false;
    if (namelen >= PROP_NAME_MAX) return false;
    if (namelen < 1) return false;
    if (name[0] == '.') return false;
    if (name[namelen - 1] == '.') return false;

    /* Only allow alphanumeric, plus '.', '-', or '_' */
    /* Don't allow ".." to appear in a property name */
    for (i = 0; i < namelen; i++) {
        if (name[i] == '.') {
            if (previous_was_dot == true) return false;
            previous_was_dot = true;
            continue;
        }
        previous_was_dot = false;
        if (name[i] == '_' || name[i] == '-') continue;
        if (name[i] >= 'a' && name[i] <= 'z') continue;
        if (name[i] >= 'A' && name[i] <= 'Z') continue;
        if (name[i] >= '0' && name[i] <= '9') continue;
        return false;
    }

    return true;
}

可以看出對屬性名有著嚴格的限制，首先關于屬性的長度，在kitkat\bionic\libc\include\sys\system_properties.h中有定義：

#define PROP_NAME_MAX   42
#define PROP_VALUE_MAX  92

即屬性名的長度不得超過42，不得小于1， 而屬性值的長度不得超過92，屬性名的第一個字符和最后一個都不得為點(.)，也不得出現連續的點(..)，屬性名的字符范圍限制在下劃線(_)、連接符(-)、點(.)、大小寫英文字母(A-Z和a-z)、數字0-9當中，

如果屬性名合法，便會執行__system_property_find()函式去尋找該屬性名是否已經存在，該函式定義在kitkat\bionic\libc\bionic\system_properties.c中，其最終呼叫該檔案中的find_property()函式在屬性字典樹結構中去查找該屬性名是否已經存在，這里呼叫find_property()的時候就是以前面提到的全域變數__system_property_area__為物件，在其所指向的記憶體空間中查找，

能在該樹形結構中找到的屬性，只要不是"ro."開頭的屬性，就直接呼叫system_properties.c檔案中的__system_property_update()函式對屬性值進行更新，對于一些特殊的屬性，property_set函式進行了特殊處理，"ro."開頭的屬性，因為在設定上只能初始話一次，所以不得更改；"net."開頭的屬性值發生更改后，必須也對"net.change"的屬性值發生更改，比如陳述句property_set("net.hostname", "xxxx")將屬性"net.hostname"的值設定為"xxxx"，那么必然也會執行property_set("net.change", "net.hostname")將屬性"net.change"屬性的值改為"net.hostname"，代表屬性"net.hostname"發生了更改；"persist."開頭的屬性則會在設備/data/property目錄下建立對應的檔案，該檔案以屬性名為檔案名，屬性值為檔案內容，

init行程的組態檔init.rc中存在一些依賴屬性值來觸發的action，所以property_set函式在更新或添加一個屬性值過后，需要通過property_changed()間接呼叫queue_property_triggers()函式，去查看這個屬性的更改會不會觸發哪些action，如果會觸發，則將這些action添加到action任務串列中，等待順序執行，至此，屬性檔案的加載動作結束，

函式start_property_service在加載完屬性檔案后，便通過陳述句fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0)來創建socket：

// kitkat/system/core/init/util.c

int create_socket(const char *name, int type, mode_t perm, uid_t uid, gid_t gid)
{
    struct sockaddr_un addr;
    int fd, ret;
    char *secon;

    fd = socket(PF_UNIX, type, 0);
    if (fd < 0) {
        ERROR("Failed to open socket '%s': %s\n", name, strerror(errno));
        return -1;
    }

    memset(&addr, 0 , sizeof(addr));
    addr.sun_family = AF_UNIX;
    snprintf(addr.sun_path, sizeof(addr.sun_path), ANDROID_SOCKET_DIR"/%s",
             name);

    ret = unlink(addr.sun_path);
    if (ret != 0 && errno != ENOENT) {
        ERROR("Failed to unlink old socket '%s': %s\n", name, strerror(errno));
        goto out_close;
    }

    secon = NULL;
    if (sehandle) {
        ret = selabel_lookup(sehandle, &secon, addr.sun_path, S_IFSOCK);
        if (ret == 0)
            setfscreatecon(secon);
    }

    ret = bind(fd, (struct sockaddr *) &addr, sizeof (addr));
    if (ret) {
        ERROR("Failed to bind socket '%s': %s\n", name, strerror(errno));
        goto out_unlink;
    }

    setfscreatecon(NULL);
    freecon(secon);

    chown(addr.sun_path, uid, gid);
    chmod(addr.sun_path, perm);

    INFO("Created socket '%s' with mode '%o', user '%d', group '%d'\n",
         addr.sun_path, perm, uid, gid);

    return fd;

out_unlink:
    unlink(addr.sun_path);
out_close:
    close(fd);
    return -1;
}

首先出現的結構體型別sockaddr_un位于kitkat\bionic\libc\kernel\common\linux\un.h：

/****************************************************************************
 ****************************************************************************
 ***
 ***   This header was automatically generated from a Linux kernel header
 ***   of the same name, to make information necessary for userspace to
 ***   call into the kernel available to libc.  It contains only constants,
 ***   structures, and macros generated from the original header, and thus,
 ***   contains no copyrightable information.
 ***
 ***   To edit the content of this header, modify the corresponding
 ***   source file (e.g. under external/kernel-headers/original/) then
 ***   run bionic/libc/kernel/tools/update_all.py
 ***
 ***   Any manual change here will be lost the next time this script will
 ***   be run. You've been warned!
 ***
 ****************************************************************************
 ****************************************************************************/
#ifndef _LINUX_UN_H
#define _LINUX_UN_H
#define UNIX_PATH_MAX 108
struct sockaddr_un {
/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
 sa_family_t sun_family;
 char sun_path[UNIX_PATH_MAX];
};
#endif
/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */

根據注釋可以看到這個檔案是由腳本檔案自動生成的，所以根據注釋提示在kitkat\external\kernel-headers\original\linux\un.h可以找到原始定義：

#ifndef _LINUX_UN_H
#define _LINUX_UN_H

#define UNIX_PATH_MAX	108

struct sockaddr_un {
	sa_family_t sun_family;	/* AF_UNIX */
	char sun_path[UNIX_PATH_MAX];	/* pathname */
};

#endif /* _LINUX_UN_H */

而samifily_t型別通過層層尋找也可以找到：

// kitkat\bionic\libc\include\sys\un.h

#include <sys/_types.h>
typedef __sa_family_t sa_family_t;

#include <linux/un.h>

// Z:\amlogic-s905L\kitkat\bionic\libc\include\sys\_types.h

typedef __uint16_t	__sa_family_t;	/* sockaddr address family type */

也就是是說，這個變數代表可以理解為socket的地址型別或協議族型別，這些不同協議型別的取值，系統已經定義了對應常量，可以在kitkat\bionic\libc\include\sys\socket.h中看到，內容比較多，就不羅列了，

回到create_socket函式，可以看到首先通過socket函式創建了行程通信協議型別（PF_UNIX）、雙向連續且可信賴的資料流（SOCK_STREAM ）即TCP型別的socket，然后對sockaddr_un型別的實體成員addr進行賦值，之后unlink函式根據賦值的addr.sun_path洗掉舊的socket檔案，通過bind函式將創建的socket與指定的IP和埠系結起來，最后通過chmod()和chown()函式對該socket檔案賦予正確的所屬用戶和權限，其中addr.sun_path賦值為：ANDROID_SOCKET_DIR/PROP_SERVICE_NAME，這兩個常量定義如下：

// kitkat\system\core\include\cutils\sockets.h

#define ANDROID_SOCKET_DIR		"/dev/socket"


// kitkat\bionic\libc\include\sys\_system_properties.h
#define PROP_SERVICE_NAME "property_service"

至此，start_property_service函式中create_socket函式執行完畢，之后便通過陳述句listen(fd, 8)將該socket設定為listen模式，并將全域靜態變數property_set_fd設定為socket函式回傳值，該全域變數初始值為-1，而socket函式只有在出錯的情況下才會回傳-1，即正常情況下會回傳一個大于0的整形socket描述符，全域變數property_set_fd此處的賦值在后面會用到，

start_property_service函式執行結束，代表著init.c的main函式中 queue_builtin_action(property_service_init_action, "property_service_init")這個action執行結束，那么在main函式中繼續向下看，可以看到陳述句queue_builtin_action(queue_property_triggers_action, "queue_property_triggers")，這個也不難理解，因為至此屬性檔案均已加載完畢，那么init.rc檔案中那些將屬性值作為觸發器的到action，此時就可以檢測觸發了，至此，第二模塊的呼叫鏈如下圖：

3、持續監聽socket

init.c檔案中main函式，末尾有一個 是個死回圈for(;;)，回圈內部關于property，會檢測property_set_fd的值是否大于0，如果大于0，則將執行handle_property_set_fd()函式，而這個值我們剛剛才說到其已經被賦值，所以來看看handle_property_set_fd()函式吧：

// kitkat/system/core/init/property_service.c

void handle_property_set_fd()
{
    prop_msg msg;
    int s;
    int r;
    int res;
    struct ucred cr;
    struct sockaddr_un addr;
    socklen_t addr_size = sizeof(addr);
    socklen_t cr_size = sizeof(cr);
    char * source_ctx = NULL;

    if ((s = accept(property_set_fd, (struct sockaddr *) &addr, &addr_size)) < 0) {
        return;
    }

    /* Check socket options here */
    if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) {
        close(s);
        ERROR("Unable to receive socket options\n");
        return;
    }

    r = TEMP_FAILURE_RETRY(recv(s, &msg, sizeof(msg), 0));
    if(r != sizeof(prop_msg)) {
        ERROR("sys_prop: mis-match msg size received: %d expected: %d errno: %d\n",
              r, sizeof(prop_msg), errno);
        close(s);
        return;
    }

    switch(msg.cmd) {
    case PROP_MSG_SETPROP:
        msg.name[PROP_NAME_MAX-1] = 0;
        msg.value[PROP_VALUE_MAX-1] = 0;

        if (!is_legal_property_name(msg.name, strlen(msg.name))) {
            ERROR("sys_prop: illegal property name. Got: \"%s\"\n", msg.name);
            close(s);
            return;
        }

        getpeercon(s, &source_ctx);

        if(memcmp(msg.name,"ctl.",4) == 0) {
            // Keep the old close-socket-early behavior when handling
            // ctl.* properties.
            close(s);
            if (check_control_perms(msg.value, cr.uid, cr.gid, source_ctx)) {
                handle_control_message((char*) msg.name + 4, (char*) msg.value);
            } else {
                ERROR("sys_prop: Unable to %s service ctl [%s] uid:%d gid:%d pid:%d\n",
                        msg.name + 4, msg.value, cr.uid, cr.gid, cr.pid);
            }
        } else {
            if (check_perms(msg.name, cr.uid, cr.gid, source_ctx)) {
                property_set((char*) msg.name, (char*) msg.value);
            } else {
                ERROR("sys_prop: permission denied uid:%d  name:%s\n",
                      cr.uid, msg.name);
            }

            // Note: bionic's property client code assumes that the
            // property server will not close the socket until *AFTER*
            // the property is written to memory.
            close(s);
        }
        freecon(source_ctx);
        break;

    default:
        close(s);
        break;
    }
}

之前通過socket()函式創建的服務端socket，在經過bind()和listen()之后，最終在這里通過accept()函式真正接收socket客戶端的連線，之后通過getsockopt()函式檢測socket相關狀態資訊，然后使用宏TEMP_FAILURE_RETRY忽略recv()函式中斷造成的錯誤，去接收socket客戶端發送來的訊息，其只對設定屬性的訊息(PROP_MSG_SETPROP)進行處理，

如果是"ctl."開頭的控制命令屬性（包括ctl.start、ctl.stop、ctl.restart），首先需要通過check_control_perms()函式檢測有沒有對該控制命令的執行權限：

// kitkat/system/core/init/property_service.c

/*
 * White list of UID that are allowed to start/stop services.
 * Currently there are no user apps that require.
 */
struct {
    const char *service;
    unsigned int uid;
    unsigned int gid;
} control_perms[] = {
    { "dumpstate",AID_SHELL, AID_LOG },
    { "ril-daemon",AID_RADIO, AID_RADIO },
     {NULL, 0, 0 }
};

static int check_control_perms(const char *name, unsigned int uid, unsigned int gid, char *sctx) {

    int i;
    if (uid == AID_SYSTEM || uid == AID_ROOT)
      return check_control_mac_perms(name, sctx);

    /* Search the ACL */
    for (i = 0; control_perms[i].service; i++) {
        if (strcmp(control_perms[i].service, name) == 0) {
            if ((uid && control_perms[i].uid == uid) ||
                (gid && control_perms[i].gid == gid)) {
                return check_control_mac_perms(name, sctx);
            }
        }
    }
    return 0;
}

可以看到system和root用戶是擁有該權限的，其他程式通過對比control_perms陣列中中的uid和gid，如果權限符合則也擁有執行該控制命令的權限，即會執行handle_control_message()函式去執行具體的命令，鑒于其呼叫鏈復雜，所以后面再細說說這個函式，

先看看非控制命令的屬性設定，其先通過check_perm()函式檢測相關權限，不過這次是和陣列property_perms中的uid和gid做對比，比如設定"net."開頭的屬性，則需要行程的uid為：AID_SYSTEM，如果擁有對該屬性的設定權限，則呼叫前面決議過的property_set()函式直接設定該屬性的值，property_perms陣列如下：

// kitkat/system/core/init/property_service.c

* White list of permissions for setting property services. */
struct {
    const char *prefix;
    unsigned int uid;
    unsigned int gid;
} property_perms[] = {
    { "net.rmnet0.",      AID_RADIO,    0 },
    { "net.gprs.",        AID_RADIO,    0 },
    { "net.ppp",          AID_RADIO,    0 },
    { "net.qmi",          AID_RADIO,    0 },
    { "net.lte",          AID_RADIO,    0 },
    { "net.cdma",         AID_RADIO,    0 },
    { "ril.",             AID_RADIO,    0 },
    { "gsm.",             AID_RADIO,    0 },
    { "persist.radio",    AID_RADIO,    0 },
    { "net.dns",          AID_RADIO,    0 },
    { "sys.usb.config",   AID_RADIO,    0 },
    { "net.",             AID_SYSTEM,   0 },
    { "dev.",             AID_SYSTEM,   0 },
    { "runtime.",         AID_SYSTEM,   0 },
    { "hw.",              AID_SYSTEM,   0 },
    { "sys.",             AID_SYSTEM,   0 },
    { "sys.powerctl",     AID_SHELL,    0 },
    { "service.",         AID_SYSTEM,   0 },
    { "wlan.",            AID_SYSTEM,   0 },
    { "bluetooth.",       AID_BLUETOOTH,   0 },
    { "dhcp.",            AID_SYSTEM,   0 },
    { "dhcp.",            AID_DHCP,     0 },
    { "debug.",           AID_SYSTEM,   0 },
    { "debug.",           AID_SHELL,    0 },
    { "log.",             AID_SHELL,    0 },
    { "service.adb.root", AID_SHELL,    0 },
    { "service.adb.tcp.port", AID_SHELL,    0 },
    { "persist.sys.",     AID_SYSTEM,   0 },
    { "persist.service.", AID_SYSTEM,   0 },
    { "persist.security.", AID_SYSTEM,   0 },
    { "persist.service.bdroid.", AID_BLUETOOTH,   0 },
    { "selinux."         , AID_SYSTEM,   0 },
    { NULL, 0, 0 }
};

現在我們來看看前面遺留的handle_control_message()函式，其主要是做了程式調度的作業，后面看模塊結尾處呼叫鏈的圖更清晰一些，

用bootanim這個服務為例，設定("ctl.stop", "bootanim")這樣的指令，會先判斷這個服務是否在運行，如果在運行則會殺死bootanim這個行程，并將"init.svc.bootanim"屬性的值改為"stopping"；如果這個服務沒在運行，則直接將"init.svc.bootanim"屬性的值改為"stopped"，

指令("ctl.start", "bootanim")則是直接呼叫service_start()函式做一些處理（代碼有部分省略）：

// kitkat/system/core/init/init.c

void service_start(struct service *svc, const char *dynamic_args)
{
    …………

    pid = fork();

    if (pid == 0) {
        struct socketinfo *si;
        struct svcenvinfo *ei;
        char tmp[32];
        int fd, sz;

        umask(077);
        if (properties_inited()) {
            get_property_workspace(&fd, &sz);
            sprintf(tmp, "%d,%d", dup(fd), sz);
            add_environment("ANDROID_PROPERTY_WORKSPACE", tmp);
        }

        for (ei = svc->envvars; ei; ei = ei->next)
            add_environment(ei->name, ei->value);

        setsockcreatecon(scon);

        for (si = svc->sockets; si; si = si->next) {
            int socket_type = (
                    !strcmp(si->type, "stream") ? SOCK_STREAM :
                        (!strcmp(si->type, "dgram") ? SOCK_DGRAM : SOCK_SEQPACKET));
            int s = create_socket(si->name, socket_type,
                                  si->perm, si->uid, si->gid);
            if (s >= 0) {
                publish_socket(si->name, s);
            }
        }

        …………

        if (!dynamic_args) {
            if (execve(svc->args[0], (char**) svc->args, (char**) ENV) < 0) {
                ERROR("cannot execve('%s'): %s\n", svc->args[0], strerror(errno));
            }
        } else {
            char *arg_ptrs[INIT_PARSER_MAXARGS+1];
            int arg_idx = svc->nargs;
            char *tmp = strdup(dynamic_args);
            char *next = tmp;
            char *bword;

            /* Copy the static arguments */
            memcpy(arg_ptrs, svc->args, (svc->nargs * sizeof(char *)));

            while((bword = strsep(&next, " "))) {
                arg_ptrs[arg_idx++] = bword;
                if (arg_idx == INIT_PARSER_MAXARGS)
                    break;
            }
            arg_ptrs[arg_idx] = '\0';
            execve(svc->args[0], (char**) arg_ptrs, (char**) ENV);
        }
        _exit(127);
    }

    …………

    if (properties_inited())
        notify_service_state(svc->name, "running");
}

首先可以看到fork函式，學習《linux c語言 fork() 和 exec 函式的簡介和用法》這篇博文可以知道，其以init行程為父行程創建子行程，并通過umask()函式設定行程檔案的默認權限掩碼，該行程用于后續執行我們要啟動的服務，

在該行程中，首先通過properties_inited()函式獲取全域靜態變數property_area_inited的值，還記得在第一模塊的初始化部分，init_property_area()函式就已經將property_area_inited的值置為1，所以程式向下執行get_property_workspace()，這個函式則是獲取全域靜態變數pa_workspace的成員資訊，此刻，時間線再次收束，還記得第一模塊初始化部分init_property_area()函式中的陳述句：init_workspace(&pa_workspace, 0)就已經將"/dev/__properties__"這個檔案以只讀方式打開，并將檔案句柄傳給了pa_workspace的fd成員，所以接著執行后面的add_environment()函式將dup()過的檔案句柄添加到名為ANDROID_PROPERTY_WORKSPACE的環境變數中去，除了會添加服務自身的環境變數外，還會添加服務中這些socket的環境變數，以init.rc檔案中的netd服務為例：

service netd /system/bin/netd
    class main
    socket netd stream 0660 root system
    socket dnsproxyd stream 0660 root inet
    socket mdns stream 0660 root system

之后的代碼設定了uid和gid等相關安全問題，此時一切準備就緒，程式根據啟動服務有沒有相關引數，通過execve()函式正式拉起執行目標服務，結束后陳述句_exit(127)退出子行程，以netd服務為例，將屬性"init.svc.netd"的值設定為"running"，

至此，service_start()函式結束，handle_control_message()函式結束，main函式的死回圈中一次handle_property_set_fd()函式呼叫結束，來看看第三模塊相關呼叫鏈：

4、外部呼叫

4.1 java層

java層對property屬性的呼叫介面位于：kitkat/frameworks/base/core/java/android/os/SystemProperties.java；其中的主要介面SystemProperties.get()和SystemProperties.set()都是通過jni介面native_get()和native_set()對C/C++層呼叫，

在kitkat\frameworks\base\core\jni\android_os_SystemProperties.cpp檔案中可以看到，這兩個介面最終都是指向了kitkat\system\core\libcutils\properties.c中，

這個c檔案中的property_get()、prooerty_set()函式相同的介面有三個，根據下面的注釋可以看到，這兩種是針對其他的呼叫方式的實作，所以不用管這兩種實作，主要來看第一種實作，

/*
 * The Linux simulator provides a "system property server" that uses IPC
 * to set/get/list properties.  The file descriptor is shared by all
 * threads in the process, so we use a mutex to ensure that requests
 * from multiple threads don't get interleaved.
 */

…………

/* SUPER-cheesy place-holder implementation for Win32 */

//  kitkat\system\core\libcutils\properties.c

#include <sys/_system_properties.h>

int property_set(const char *key, const char *value)
{
    if (!strcmp("persist.sys.autosleep", key) || !strcmp("persist.sys.autosleeptime", key)) {
        __system_property_set("ctl.start", "auto_sleep");
    }
    return __system_property_set(key, value);
}

int property_get(const char *key, char *value, const char *default_value)
{
    int len;

    len = __system_property_get(key, value);
    if(len > 0) {
        return len;
    }
    
    if(default_value) {
        len = strlen(default_value);
        memcpy(value, default_value, len + 1);
    }
    return len;
}

輾轉_system_properties.h和system_properties.h，最終又回到了kitkat\bionic\libc\bionic\system_properties.c中，對！就是在第一模塊初始化的時候所出現的那個檔案，在這個檔案可以找到__system_property_get()和__system_property_set()這兩個介面的實作，先來看看__system_property_set()函式：

//  kitkat\bionic\libc\include\sys\_system_properties.h

struct prop_msg 
{
    unsigned cmd;
    char name[PROP_NAME_MAX];
    char value[PROP_VALUE_MAX];
};


// kitkat\bionic\libc\bionic\system_properties.c

int __system_property_set(const char *key, const char *value)
{
    int err;
    prop_msg msg;

    if(key == 0) return -1;
    if(value == 0) value = "";
    if(strlen(key) >= PROP_NAME_MAX) return -1;
    if(strlen(value) >= PROP_VALUE_MAX) return -1;

    memset(&msg, 0, sizeof msg);
    msg.cmd = PROP_MSG_SETPROP;
    strlcpy(msg.name, key, sizeof msg.name);
    strlcpy(msg.value, value, sizeof msg.value);

    err = send_prop_msg(&msg);
    if(err < 0) {
        return err;
    }

    return 0;
}

其首先創建一個prop_msg型別的結構體實體msg，將需要設定的屬性名和屬性值賦值給msg的name和value成員，然后將PROP_MSG_SETPROP作為訊息命令賦值給cmd成員，還記得第三模塊socket服務端監聽并接收客戶端連接訊息的時候，其只對PROP_MSG_SETPROP這個訊息做回應，待發送訊息準備完畢，通過send_prop_msg()函式發送訊息，

// kitkat\bionic\libc\bionic\system_properties.c

static const char property_service_socket[] = "/dev/socket/" PROP_SERVICE_NAME;

static int send_prop_msg(prop_msg *msg)
{
    struct pollfd pollfds[1];
    struct sockaddr_un addr;
    socklen_t alen;
    size_t namelen;
    int s;
    int r;
    int result = -1;

    s = socket(AF_LOCAL, SOCK_STREAM, 0);
    if(s < 0) {
        return result;
    }

    memset(&addr, 0, sizeof(addr));
    namelen = strlen(property_service_socket);
    strlcpy(addr.sun_path, property_service_socket, sizeof addr.sun_path);
    addr.sun_family = AF_LOCAL;
    alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1;

    if(TEMP_FAILURE_RETRY(connect(s, (struct sockaddr *) &addr, alen)) < 0) {
        close(s);
        return result;
    }

    r = TEMP_FAILURE_RETRY(send(s, msg, sizeof(prop_msg), 0));

    if(r == sizeof(prop_msg)) {
        pollfds[0].fd = s;
        pollfds[0].events = 0;
        r = TEMP_FAILURE_RETRY(poll(pollfds, 1, 250 /* ms */));
        if (r == 1 && (pollfds[0].revents & POLLHUP) != 0) {
            result = 0;
        } else {
            result = 0;
        }
    }

    close(s);
    return result;
}

第二模塊中創建socket的socket檔案路徑位于"/dev/socket/property_service"，send_prop_msg()函式中首先創建socket，并將其做為客戶端通過connect()函式連接之前創建的socket服務端，連接成功之后，通過send()函式將修改屬性的PROP_MSG_SETPROP訊息發送給服務端，第三模塊說到socket服務端持續監聽并接受客戶端的訊息，就是我們這里發送的訊息了，

再來看看__system_property_get()函式：

// kitkat\bionic\libc\bionic\system_properties.c

int __system_property_get(const char *name, char *value)
{
    const prop_info *pi = __system_property_find(name);

    if(pi != 0) {
        return __system_property_read(pi, 0, value);
    } else {
        value[0] = 0;
        return 0;
    }
}

其先通過__system_property_find()函式輾轉呼叫之前出現過的find_property()函式，在屬性字典樹中尋找目標屬性，如果能找到該屬性，則通過__system_property_read()函式讀取該屬性的值，

這里有一個問題，那就是__system_property_set()函式是通過socket方式請求init行程，去對屬性記憶體空間進行設定，在第一模塊初始化的時候，init行程通過呼叫__system_property_area_init()函式獲取到了屬性記憶體檔案的讀寫權限，所以可以訪問屬性記憶體空間，但是__system_property_get()函式并未請求init行程，也沒有對屬性記憶體空間有讀寫權限，那它是如何獲取到屬性值的呢？原來是在該檔案里，有個和__system_property_area_init()類似的介面：__system_properties_init()，拿出來對比一下：

//  kitkat\bionic\libc\bionic\system_properties.c

#################################
int __system_property_area_init()
{
    return map_prop_area_rw();
}
#################################
int __system_properties_init()
{
    return map_prop_area();
}
#################################
static int map_prop_area()
{
    …………
    fd = open(property_filename, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
    if (fd >= 0) {
        /* For old kernels that don't support O_CLOEXEC */
        ret = fcntl(fd, F_SETFD, FD_CLOEXEC);
        if (ret < 0)
            goto cleanup;
    }

    if ((fd < 0) && (errno == ENOENT)) {
        fd = get_fd_from_env();
        fromFile = false;
    }

    …………
    prop_area *pa = mmap(NULL, pa_size, PROT_READ, MAP_SHARED, fd, 0);

    …………

    __system_property_area__ = pa;

cleanup:
    if (fromFile) {
        close(fd);
    }

    return result;
}

這里因為只是獲取屬性值，故以只讀方式打開屬性記憶體檔案，如果打開失敗，通過get_fd_from_env()函式的陳述句：getenv("ANDROID_PROPERTY_WORKSPACE")從環境變數中獲取該屬性檔案的檔案描述符，這個環境變數ANDROID_PROPERTY_WORKSPACE正是第三模塊service_start()函式中，陳述句add_environment("ANDROID_PROPERTY_WORKSPACE", tmp)所添加的，后續mmap()函式映射進記憶體的時候也是只讀方式，并將記憶體起始位置賦值給__system_property_area__ ，這個全域變數這里又一次出現了，__system_property_get()函式能找到目標屬性位置，就是以它為物件，在其所指向的記憶體空間中查找，

那么問題就剩下__system_properties_init()何時呼叫了，在文章開頭我所參考的文章《深入講解Android Property機制》中，已經有詳細說明，我還不太理解，就不細說了，大概意思就是在main函式運行前，加載C運行期庫初始化運行環境的時候就已經呼叫了，

4.2、C/C++層

以開機影片的程式為例，其就是直接呼叫kitkat\system\core\libcutils\properties.c的property_get()和property_set()介面，而這個檔案我們剛剛已經看過了，所以不再贅述，

// kitkak/frameworks/base/cmds/bootanimation/BootAnimation.cpp

#include <cutils/properties.h>

4.3、shell層

通常我們通過adb連接到設備后，可以通過setprop設定某個屬性值，通過getprop獲取某個屬性值，或者所有屬性值，那么這里的原理是什么呢？首先可以在system/bin目錄下看到，setprop和getprop這兩個可執行檔案，且都是鏈接到toolbox這個檔案，那么我們來找一下toolbox的源代碼位置吧，

root@xxx:/ # ls -l /system/bin/setprop
lrwxr-xr-x root     shell             2021-03-19 15:54 setprop -> toolbox
root@xxx:/ # ls -l /system/bin/getprop
lrwxr-xr-x root     shell             2021-03-19 15:54 getprop -> toolbox

在kitkak/system/core/toolbox目錄下可以找到這兩個程式的源檔案getprop.c和setprop.c：

//  kitkak/system/core/toolbox/setprop.c

#include <stdio.h>

#include <cutils/properties.h>

int setprop_main(int argc, char *argv[])
{
    if(argc != 3) {
        fprintf(stderr,"usage: setprop <key> <value>\n");
        return 1;
    }

    if(property_set(argv[1], argv[2])){
        fprintf(stderr,"could not set property\n");
        return 1;
    }

    return 0;
}

顯而易見，和java、c/c++層所呼叫的介面相同，都是指向了kitkat\system\core\libcutils\properties.c，

這一模塊的呼叫關系也用圖總結一下：

5、總結

先來看看總體的呼叫圖吧，如果覺得字太小可以去畫圖網站看原圖，可以縮放觀看，因為追蹤的是呼叫鏈細節，所以看起來有一代點復雜，但這能讓你看到程式運行的每一處細節，

如果覺得太深入代碼而忽略了整體的概要框架理解起來更清晰，那么我們借用《Android Property屬性的實作細節》，這篇文章的圖片來簡要概括一下，

首先，開機啟動后property service服務從幾個prop屬性檔案中把屬性資料讀取出來，映射存盤到一塊共享記憶體中，這塊共享記憶體只提供讀權限給用戶行程，只有property service服務對屬性資料擁有寫權限，且只有init行程中呼叫了property service中寫屬性的介面，而init行程提供socket方式接收set屬性的訊息，所以用戶行程想要set屬性，就可以通過socket方式發送set屬性的訊息給init行程，init行程呼叫set屬性的介面，完成對屬性的寫入操作，

6、補充

博文到這里就結束了，首先很感謝各位前輩總結、分享的博文和技巧，由于自身太菜，這篇博文斷斷續續寫了兩周，創作不易，歡迎分享，但請不要隨意轉載呀，有需要的話可以私我，文章有錯誤的地方歡迎指正，我會在這里進行補充，