AudioPolicyService与HAL接口

这里主要讲简练地讲了Serivce与HAL的接口关系，两个重要的数据结构，主要是android4.4，不同方案可以有一些不一样，5.1也有些不同。AudioPolicyManager不在HAL层，直接移到framework下面了。

hw_module_t (有通过methods->open成员，这里顺便再讲下hw_methods_t)

hw_device_t （有直接close成员）

这两个成员在hardware.h中，有必要记住成员关系

struct hw_module_t;
struct hw_module_methods_t;
struct hw_device_t;

/**
* 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;

/**
* The API version of the implemented module. The module owner is
* responsible for updating the version when a module interface has
* changed.
*
* The derived modules such as gralloc and audio own and manage this field.
* The module user must interpret the version field to decide whether or
* not to inter-operate with the supplied module implementation.
* For example, SurfaceFlinger is responsible for making sure that
* it knows how to manage different versions of the gralloc-module API,
* and AudioFlinger must know how to do the same for audio-module API.
*
* The module API version should include a major and a minor component.
* For example, version 1.0 could be represented as 0x0100. This format
* implies that versions 0x0100-0x01ff are all API-compatible.
*
* In the future, libhardware will expose a hw_get_module_version()
* (or equivalent) function that will take minimum/maximum supported
* versions as arguments and would be able to reject modules with
* versions outside of the supplied range.
*/
uint16_t module_api_version;
#define version_major module_api_version
/**
* version_major/version_minor defines are supplied here for temporary
* source code compatibility. They will be removed in the next version.
* ALL clients must convert to the new version format.
*/

/**
* The API version of the HAL module interface. This is meant to
* version the hw_module_t, hw_module_methods_t, and hw_device_t
* structures and definitions.
*
* The HAL interface owns this field. Module users/implementations
* must NOT rely on this value for version information.
*
* Presently, 0 is the only valid value.
*/
uint16_t hal_api_version;
#define version_minor hal_api_version

/** Identifier of module */
const char *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[32-7];

} **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);     //这个open方法把module和device关联起来了，其它的方法都是与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;

/**
* Version of the module-specific device API. This value is used by
* the derived-module user to manage different device implementations.
*
* The module user is responsible for checking the module_api_version
* and device version fields to ensure that the user is capable of
* communicating with the specific module implementation.
*
* One module can support multiple devices with different versions. This
* can be useful when a device interface changes in an incompatible way
* but it is still necessary to support older implementations at the same
* time. One such example is the Camera 2.0 API.
*
* This field is interpreted by the module user and is ignored by the
* HAL interface itself.
*/
uint32_t version;

/** reference to the module this device belongs to */
struct hw_module_t* module;

/** padding reserved for future use */
uint32_t reserved[12];

/** Close this device */
int (*close)(struct hw_device_t* device);

} **hw_device_t**;

在4.4中，AudioFlingerService的构造函数（framework/av/service/audioflinger/AudioFlingerService.cpp）

1.1，

hw_get_module(AUDIO_POLICY_HARDWARE_MODULE_ID, &module);

先通过hw_get_module这个方法，拿到hal层的module

2.2，

audio_policy_dev_open(module, &mpAudioPolicyDev);

这里对应到hal层hw_module_t的open方法

audio_policy.h

440 static inline int audio_policy_dev_open(const hw_module_t* module,
441                                     struct audio_policy_device** device)
442 {
443     return module->methods->open(module, AUDIO_POLICY_INTERFACE,
444                                  (hw_device_t**)device);
445 }

这个open就是对应audio_polic.c的open

310 static int default_ap_dev_open(const hw_module_t* module, const char* name,
311                                hw_device_t** device)
312 {
313     struct default_ap_device *dev;
314
315     *device = NULL;
316
317     if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0)
318         return -EINVAL;
319
320     dev = (struct default_ap_device *)calloc(1, sizeof(*dev));
321     if (!dev)
322         return -ENOMEM;
323
324     dev->device.common.tag = HARDWARE_DEVICE_TAG;
325     dev->device.common.version = 0;
326     dev->device.common.module = (hw_module_t *)module;
327     dev->device.common.close = default_ap_dev_close;
328     dev->device.create_audio_policy = create_default_ap;
329     dev->device.destroy_audio_policy = destroy_default_ap;
330
331     *device = &dev->device.common;
332
333     return 0;
334 }
335
336 static struct hw_module_methods_t default_ap_module_methods = {
337     .open = default_ap_dev_open,
338 };

这个create就带出一大串方法，这些方法就供给上层调用，让hal自己来实现。

1.3

rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this,
&mpAudioPolicy);

这个create_audio_policy就是4.2指的default_ap_dev_open，来看这个函数的实现。

static int create_default_ap(const struct audio_policy_device *device,
struct audio_policy_service_ops *aps_ops,
void *service,
struct audio_policy **ap)
{
struct default_ap_device *dev;
struct default_audio_policy *dap;
int ret;

*ap = NULL;

if (!service || !aps_ops)
return -EINVAL;

dap = (struct default_audio_policy *)calloc(1, sizeof(*dap));
if (!dap)
return -ENOMEM;

dap->policy.set_device_connection_state = ap_set_device_connection_state;
dap->policy.get_device_connection_state = ap_get_device_connection_state;
dap->policy.set_phone_state = ap_set_phone_state;
dap->policy.set_ringer_mode = ap_set_ringer_mode;
dap->policy.set_force_use = ap_set_force_use;
dap->policy.get_force_use = ap_get_force_use;
dap->policy.set_can_mute_enforced_audible =
ap_set_can_mute_enforced_audible;
dap->policy.init_check = ap_init_check;
dap->policy.get_output = ap_get_output;
dap->policy.start_output = ap_start_output;
dap->policy.stop_output = ap_stop_output;
dap->policy.release_output = ap_release_output;
dap->policy.get_input = ap_get_input;
dap->policy.start_input = ap_start_input;
dap->policy.stop_input = ap_stop_input;
dap->policy.release_input = ap_release_input;
dap->policy.init_stream_volume = ap_init_stream_volume;
dap->policy.set_stream_volume_index = ap_set_stream_volume_index;
dap->policy.get_stream_volume_index = ap_get_stream_volume_index;
dap->policy.set_stream_volume_index_for_device = ap_set_stream_volume_index_for_device;
dap->policy.get_stream_volume_index_for_device = ap_get_stream_volume_index_for_device;
dap->policy.get_strategy_for_stream = ap_get_strategy_for_stream;
dap->policy.get_devices_for_stream = ap_get_devices_for_stream;
dap->policy.get_output_for_effect = ap_get_output_for_effect;
dap->policy.register_effect = ap_register_effect;
dap->policy.unregister_effect = ap_unregister_effect;
dap->policy.set_effect_enabled = ap_set_effect_enabled;
dap->policy.is_stream_active = ap_is_stream_active;
dap->policy.dump = ap_dump;

dap->policy.is_offload_supported = ap_is_offload_supported;

dap->service = service;
dap->aps_ops = aps_ops;

*ap = &dap->policy;
return 0;
}

1.4

rc = mpAudioPolicy->init_check(mpAudioPolicy);
ALOGE_IF(rc, "couldn't init_check the audio policy (%s)", strerror(-rc));
if (rc)
return;

init_check调用，hal也没实现。

以上四步基本上就展示了Framework层与hal层交互过程。