/**

 * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM

 * and the fields of this data structure must begin with hw_module_t

 * followed by module specific information.

 */

typedef struct hw_module_t {

    /** tag must be initialized to HARDWARE_MODULE_TAG */

    uint32_t tag;  //tag，根据引文注释可以看到必须被初始化为HARDWARE_MODULE_TAG

    /** major version number for the module */

    uint16_t version_major;//主版本号

    /** minor version number of the module */

    uint16_t version_minor;//次版本号

    /** Identifier of module */

    const char *id;//模块id字符串

    /** Name of this module */

    const char *name;//模块名

    /** Author/owner/implementor of the module */

    const char *author;//作者

    /** Modules methods */

    struct hw_module_methods_t* methods;//硬件模块方法结构体

    /** module's dso */

    void* dso;//打开硬件模块的库时得到的句柄

    /** padding to 128 bytes, reserved for future use */

    uint32_t reserved[-];

} hw_module_t;

typedef struct hw_module_methods_t {

    /** Open a specific device */

    int (*open)(const struct hw_module_t* module, const char* id,//打开硬件设备函数指针

            struct hw_device_t** device);

} hw_module_methods_t;

/**

 * Every device data structure must begin with hw_device_t

 * followed by module specific public methods and attributes.

 */

typedef struct hw_device_t {

    /** tag must be initialized to HARDWARE_DEVICE_TAG */

    uint32_t tag;   //设备tag

    /** version number for hw_device_t */

    uint32_t version;//版本

    /** reference to the module this device belongs to */

    struct hw_module_t* module;//本设备归属的硬件模块

    /** padding reserved for future use */

    uint32_t reserved[];//保留

    /** Close this device */

    int (*close)(struct hw_device_t* device);//关闭设备的函数指针

} hw_device_t;

typedef struct camera_module {

    hw_module_t common;

    int (*get_number_of_cameras)(void);

    int (*get_camera_info)(int camera_id, struct camera_info *info);

} camera_module_t;

struct audio_module HAL_MODULE_INFO_SYM = {

    .common = {

        .tag = HARDWARE_MODULE_TAG,

        .module_api_version = AUDIO_MODULE_API_VERSION_0_1,

        .hal_api_version = HARDWARE_HAL_API_VERSION,

        .id = AUDIO_HARDWARE_MODULE_ID,

        .name = "NVIDIA Tegra Audio HAL",

        .author = "The Android Open Source Project",

        .methods = &hal_module_methods,

    },

};

struct audio_hw_device {

    struct hw_device_t common;

    /**

     * used by audio flinger to enumerate what devices are supported by

     * each audio_hw_device implementation.

     *

     * Return value is a bitmask of 1 or more values of audio_devices_t

     */

    uint32_t (*get_supported_devices)(const struct audio_hw_device *dev);

  ...

};

typedef struct audio_hw_device audio_hw_device_t;

　　为了更好地实现模块化，Android 8.0 对 Android 操作系统底层进行了重新架构。作为此变化的一部分，运行 Android 8.0 的设备必须支持绑定式或直通式 HAL：

• 绑定式 HAL。以 HAL 接口定义语言 (HIDL) 表示的 HAL。这些 HAL 取代了早期 Android 版本中使用的传统 HAL 和旧版 HAL。在绑定式 HAL 中，Android 框架和 HAL 之间通过 Binder 进程间通信 (IPC) 调用进行通信。所有在推出时即搭载了 Android 8.0 或后续版本的设备都必须只支持绑定式 HAL。
• 直通式 HAL。以 HIDL 封装的传统 HAL 或旧版 HAL。这些 HAL 封装了现有的 HAL，可在绑定模式和 Same-Process（直通）模式下使用。升级到 Android 8.0 的设备可以使用直通式 HAL。

1.4.1  HAL 模式要求

/*

 * Copyright (C) 2008 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <hardware/hardware.h>

#include <cutils/properties.h>

#include <dlfcn.h>

#include <string.h>

#include <pthread.h>

#include <errno.h>

#include <limits.h>

#define LOG_TAG "HAL"

#include <utils/Log.h>

/** Base path of the hal modules */

#if defined(__LP64__)

#define HAL_LIBRARY_PATH1 "/system/lib64/hw"

#define HAL_LIBRARY_PATH2 "/vendor/lib64/hw"

#else

#define HAL_LIBRARY_PATH1 "/system/lib/hw"

#define HAL_LIBRARY_PATH2 "/vendor/lib/hw"

#endif

/**

 * There are a set of variant filename for modules. The form of the filename

 * is "<MODULE_ID>.variant.so" so for the led module the Dream variants

 * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be:

 *

 * led.trout.so

 * led.msm7k.so

 * led.ARMV6.so

 * led.default.so

 */

static const char *variant_keys[] = {

    "ro.hardware",  /* This goes first so that it can pick up a different

                       file on the emulator. */

    "ro.product.board",

    "ro.board.platform",

    "ro.arch"

};

static const int HAL_VARIANT_KEYS_COUNT =

    (sizeof(variant_keys)/sizeof(variant_keys[]));

/**

 * Load the file defined by the variant and if successful

 * return the dlopen handle and the hmi.

 * @return 0 = success, !0 = failure.

 */

static int load(const char *id,

        const char *path,

        const struct hw_module_t **pHmi)

{

    int status = -EINVAL;

    void *handle = NULL;

    struct hw_module_t *hmi = NULL;

    /*

     * load the symbols resolving undefined symbols before

     * dlopen returns. Since RTLD_GLOBAL is not or'd in with

     * RTLD_NOW the external symbols will not be global

     */

    handle = dlopen(path, RTLD_NOW);

    if (handle == NULL) {

        char const *err_str = dlerror();

        ALOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");

        status = -EINVAL;

        goto done;

    }

    /* Get the address of the struct hal_module_info. */

    const char *sym = HAL_MODULE_INFO_SYM_AS_STR;

    hmi = (struct hw_module_t *)dlsym(handle, sym);

    if (hmi == NULL) {

        ALOGE("load: couldn't find symbol %s", sym);

        status = -EINVAL;

        goto done;

    }

    /* Check that the id matches */

    if (strcmp(id, hmi->id) != ) {

        ALOGE("load: id=%s != hmi->id=%s", id, hmi->id);

        status = -EINVAL;

        goto done;

    }

    hmi->dso = handle;

    /* success */

    status = ;

    done:

    if (status != ) {

        hmi = NULL;

        if (handle != NULL) {

            dlclose(handle);

            handle = NULL;

        }

    } else {

        ALOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",

                id, path, *pHmi, handle);

    }

    *pHmi = hmi;

    return status;

}

/*

 * Check if a HAL with given name and subname exists, if so return 0, otherwise

 * otherwise return negative.  On success path will contain the path to the HAL.

 */

static int hw_module_exists(char *path, size_t path_len, const char *name,

                            const char *subname)

{

    snprintf(path, path_len, "%s/%s.%s.so",

             HAL_LIBRARY_PATH2, name, subname);

    if (access(path, R_OK) == )

        return ;

    snprintf(path, path_len, "%s/%s.%s.so",

             HAL_LIBRARY_PATH1, name, subname);

    if (access(path, R_OK) == )

        return ;

    return -ENOENT;

}

int hw_get_module_by_class(const char *class_id, const char *inst,

                           const struct hw_module_t **module)

{

    int i = ;

    char prop[PATH_MAX] = {};

    char path[PATH_MAX] = {};

    char name[PATH_MAX] = {};

    char prop_name[PATH_MAX] = {};

    if (inst)

        snprintf(name, PATH_MAX, "%s.%s", class_id, inst);

    else

        strlcpy(name, class_id, PATH_MAX);

    /*

     * Here we rely on the fact that calling dlopen multiple times on

     * the same .so will simply increment a refcount (and not load

     * a new copy of the library).

     * We also assume that dlopen() is thread-safe.

     */

    /* First try a property specific to the class and possibly instance */

    snprintf(prop_name, sizeof(prop_name), "ro.hardware.%s", name);

    if (property_get(prop_name, prop, NULL) > ) {

        if (hw_module_exists(path, sizeof(path), name, prop) == ) {

            goto found;

        }

    }

    /* Loop through the configuration variants looking for a module */

    for (i= ; i<HAL_VARIANT_KEYS_COUNT; i++) {

        if (property_get(variant_keys[i], prop, NULL) == ) {

            continue;

        }

        if (hw_module_exists(path, sizeof(path), name, prop) == ) {

            goto found;

        }

    }

    /* Nothing found, try the default */

    if (hw_module_exists(path, sizeof(path), name, "default") == ) {

        goto found;

    }

    return -ENOENT;

found:

    /* load the module, if this fails, we're doomed, and we should not try

     * to load a different variant. */

    return load(class_id, path, module);

}

int hw_get_module(const char *id, const struct hw_module_t **module)

{

    return hw_get_module_by_class(id, NULL, module);

}

int hw_get_module(const char *id, const struct hw_module_t **module)

{

    int status;

    int i;

    const struct hw_module_t *hmi = NULL;

    char prop[PATH_MAX];

    char path[PATH_MAX];

    /*

     * Here we rely on the fact that calling dlopen multiple times on

     * the same .so will simply increment a refcount (and not load

     * a new copy of the library).

     * We also assume that dlopen() is thread-safe.

     */

    /* Loop through the configuration variants looking for a module */

    for (i= ; i<HAL_VARIANT_KEYS_COUNT+ ; i++) {

        if (i < HAL_VARIANT_KEYS_COUNT) {

            if (property_get(variant_keys[i], prop, NULL) == ) {//获取属性

                continue;

            }

            snprintf(path, sizeof(path), "%s/%s.%s.so",

                    HAL_LIBRARY_PATH1, id, prop);

            if (access(path, R_OK) == ) break;//检查system路径是否有库文件

            snprintf(path, sizeof(path), "%s/%s.%s.so",

                     HAL_LIBRARY_PATH2, id, prop);

            if (access(path, R_OK) == ) break;//检查vender路径是否有库文件

        } else {

            snprintf(path, sizeof(path), "%s/%s.default.so",//如果都没有，则使用缺省的

                     HAL_LIBRARY_PATH1, id);

            if (access(path, R_OK) == ) break;

        }

    }

    status = -ENOENT;

    if (i < HAL_VARIANT_KEYS_COUNT+) {

        /* load the module, if this fails, we're doomed, and we should not try

         * to load a different variant. */

        status = load(id, path, module);//装载库，得到module

    }

    return status;

}

/**

 * There are a set of variant filename for modules. The form of the filename

 * is "<MODULE_ID>.variant.so" so for the led module the Dream variants

 * of base "ro.product.board", "ro.board.platform" and "ro.arch" would be:

 *

 * led.trout.so

 * led.msm7k.so

 * led.ARMV6.so

 * led.default.so

 */

static const char *variant_keys[] = {

    "ro.hardware",  /* This goes first so that it can pick up a different

                       file on the emulator. */

    "ro.product.board",

    "ro.board.platform",

    "ro.arch"

};

/**

 * Load the file defined by the variant and if successful

 * return the dlopen handle and the hmi.

 * @return 0 = success, !0 = failure.

 */

static int load(const char *id,

        const char *path,

        const struct hw_module_t **pHmi)

{//传入硬件模块id和库所在路径，获取到硬件模块结构体

    int status;

    void *handle;

    struct hw_module_t *hmi;

    /*

     * load the symbols resolving undefined symbols before

     * dlopen returns. Since RTLD_GLOBAL is not or'd in with

     * RTLD_NOW the external symbols will not be global

     */

    handle = dlopen(path, RTLD_NOW);//打开共享库

    if (handle == NULL) {

        char const *err_str = dlerror();

        LOGE("load: module=%s\n%s", path, err_str?err_str:"unknown");

        status = -EINVAL;

        goto done;

    }

    /* Get the address of the struct hal_module_info. */

    const char *sym = HAL_MODULE_INFO_SYM_AS_STR;

    hmi = (struct hw_module_t *)dlsym(handle, sym);//解析共享库

    if (hmi == NULL) {

        LOGE("load: couldn't find symbol %s", sym);

        status = -EINVAL;

        goto done;

    }

    /* Check that the id matches */

    if (strcmp(id, hmi->id) != ) {//匹配解析出硬件模块的id和传入我们实际想要得到的模块id是否一致

        LOGE("load: id=%s != hmi->id=%s", id, hmi->id);

        status = -EINVAL;

        goto done;

    }

    hmi->dso = handle;  //将打开库得到句柄传给硬件模块的dso

    /* success */

    status = ;

    done:

    if (status != ) {

        hmi = NULL;

        if (handle != NULL) {

            dlclose(handle);

            handle = NULL;

        }

    } else {

        LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",

                id, path, *pHmi, handle);

    }

    *pHmi = hmi;//将得到的module的结果通过第三个参数传给hw_module_t

    return status;

}