void FalagardActionButton::onMouseMove(MouseEventArgs& e)
{
FalagardButton::onMouseMove(e);
if(isDraggingEnabled() && !d_dragging && !isEmpty())
{
// get position of mouse as co-ordinates local to this window.
Point localMousePos = (getMetricsMode() == Relative) ?
relativeToAbsolute(screenToWindow(e.position)) :
screenToWindow(e.position);
// if mouse button is down (but we're not yet being dragged)
if (d_leftMouseDown)
{
if (isDraggingThresholdExceeded(localMousePos))
{
// Trigger the event
WindowEventArgs args(this);
d_dragging = true;
releaseInput();
fireEvent(EventDragStarted, e, EventNamespace);
}
}
}
}
/*************************************************************************
Handler for cursor activation events
*************************************************************************/
void ComboDropList::onCursorActivate(CursorInputEventArgs& e)
{
ListWidget::onCursorActivate(e);
if (e.source == CIS_Left)
{
if (d_armed && (getChildAtPosition(e.position) == 0))
{
// if something was selected, confirm that selection.
if (getIndexSelectionStates().size() > 0)
{
WindowEventArgs args(this);
onListSelectionAccepted(args);
}
releaseInput();
}
// if we are not already armed, in response to a left cursor activation event, we auto-arm.
else
{
d_armed = true;
}
++e.handled;
}
}
void GLWidget::keyPressEvent(QKeyEvent *event)
{
// Ignore autoRepeat key events
if(event->isAutoRepeat()) return;
// Set a new moving direction
switch(event->key()) {
case Qt::Key_W:
case Qt::Key_Up:
movingTo[0]= true;
break;
case Qt::Key_D:
case Qt::Key_Right:
movingTo[1]= true;
break;
case Qt::Key_S:
case Qt::Key_Down:
movingTo[2]= true;
break;
case Qt::Key_A:
case Qt::Key_Left:
movingTo[3]= true;
break;
case Qt::Key_Shift:
camera.setRun(true);
break;
case Qt::Key_Return:
camera.lookAt(0,0,0);
break;
case Qt::Key_Escape:
releaseInput();
break;
}
}
/*************************************************************************
Handler for mouse button release events
*************************************************************************/
void ComboDropList::onMouseButtonUp(MouseEventArgs& e)
{
Listbox::onMouseButtonUp(e);
if (e.button == LeftButton)
{
if (d_armed && (getChildAtPosition(e.position) == 0))
{
// if something was selected, confirm that selection.
if (getSelectedCount() > 0)
{
WindowEventArgs args(this);
onListSelectionAccepted(args);
}
releaseInput();
}
// if we are not already armed, in response to a left button up event, we auto-arm.
else
{
d_armed = true;
}
++e.handled;
}
}
/*************************************************************************
Handler for when mouse buttons area released
*************************************************************************/
void ListHeaderSegment::onMouseButtonUp(MouseEventArgs& e)
{
// base class processing
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
// if we were pushed and mouse was released within our segment area
if (d_segmentPushed && d_segmentHover)
{
WindowEventArgs args(this);
onSegmentClicked(args);
}
else if (d_dragMoving)
{
MouseCursor::getSingleton().setImage(getMouseCursor());
WindowEventArgs args(this);
onSegmentDragStop(args);
}
// release our capture on the input data
releaseInput();
++e.handled;
}
}
void TabButton::onCursorActivate(CursorInputEventArgs& e)
{
if ((e.source == CIS_Left) && isPushed())
{
Window* sheet = getGUIContext().getRootWindow();
if (sheet)
{
// if cursor was released over this widget
// (use cursor position, as e.position has been unprojected)
if (this == sheet->getTargetChildAtPosition(
getGUIContext().getCursor().getPosition()))
{
// fire event
WindowEventArgs args(this);
onClicked(args);
}
}
++e.handled;
}
else if (e.source == CIS_Middle)
{
d_dragging = false;
releaseInput ();
++e.handled;
}
// default handling
ButtonBase::onCursorActivate(e);
}
void Window::setGrab(const bool grab)
{
if(grab)
grabInput();
else
releaseInput();
}
void DragContainer::onMouseButtonUp(MouseEventArgs& e)
{
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
if (d_dragging)
{
// release picked up state
if (d_pickedUp)
d_pickedUp = false;
// fire off event
WindowEventArgs args(this);
onDragEnded(args);
}
// check for sticky pick up
else if (d_stickyMode && !d_pickedUp)
{
initialiseDragging();
d_pickedUp = true;
// in this case, do not proceed to release inputs.
return;
}
// release our capture on the input data
releaseInput();
++e.handled;
}
}
void DragContainer::onDragEnabledChanged(WindowEventArgs& e)
{
fireEvent(EventDragEnabledChanged, e, EventNamespace);
// abort current drag operation if dragging gets disabled part way through
if (!d_draggingEnabled && d_dragging)
{
releaseInput();
}
}
void FalagardDragTitle::onMouseButtonUp(MouseEventArgs& e)
{
// Base class processing
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
releaseInput();
e.handled = true;
}
}
void FalagardActionButton::onMouseButtonUp(MouseEventArgs& e)
{
// FalagardButton::onMouseButtonUp(e);下面就是pushbutton中的部分
if ((e.button == LeftButton) && isPushed())
{
Window* sheet = System::getSingleton().getGUISheet();
if (sheet != NULL)
{
// if mouse was released over this widget
if (this == sheet->getChildAtPosition(e.position))
{
// fire event
WindowEventArgs args(this);
onClicked(args);
}
}
e.handled = true;
}
if(e.button == RightButton)
{
Window* sheet = System::getSingleton().getGUISheet();
if (sheet != NULL)
{
// if mouse was released over this widget
if (this == sheet->getChildAtPosition(e.position))
{
// fire event
WindowEventArgs args(this);
onRBClicked(args);
}
}
}
// default handling
// ButtonBase::onMouseButtonUp(e);下面就是buttonbase中的部分
Window::onMouseButtonUp(e);
if (e.button == LeftButton || e.button == RightButton)
{
releaseInput();
// event was handled by us.
e.handled = true;
}
d_leftMouseDown = false;
}
/*************************************************************************
Handler for when mouse button is released
*************************************************************************/
void MultiLineEditbox::onMouseButtonUp(MouseEventArgs& e)
{
// base class processing
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
releaseInput();
e.handled = true;
}
}
/*************************************************************************
Handler for mouse button release events
*************************************************************************/
void Titlebar::onMouseButtonUp(MouseEventArgs& e)
{
// Base class processing
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
releaseInput();
++e.handled;
}
}
/*************************************************************************
Handler for mouse button up events
*************************************************************************/
void FrameWindow::onMouseButtonUp(MouseEventArgs& e)
{
// default processing (this is now essential as it controls event firing).
Window::onMouseButtonUp(e);
if (e.button == LeftButton && isCapturedByThis())
{
// release our capture on the input data
releaseInput();
e.handled = true;
}
}
void ButtonBase::onMouseButtonUp(MouseEventArgs& e)
{
// default processing
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
releaseInput();
// event was handled by us.
e.handled = true;
}
}
/*************************************************************************
Handler for cursor activation events
*************************************************************************/
void ButtonBase::onCursorActivate(CursorInputEventArgs& e)
{
// default processing
Window::onCursorActivate(e);
if (e.source == CIS_Left)
{
releaseInput();
// event was handled by us.
++e.handled;
}
}
/*************************************************************************
Set whether this segment can be sized.
*************************************************************************/
void ListHeaderSegment::setSizingEnabled(bool setting)
{
if (d_sizingEnabled != setting)
{
d_sizingEnabled = setting;
// if sizing is now disabled, ensure sizing operation is cancelled
if (!d_sizingEnabled && d_dragSizing)
{
releaseInput();
}
WindowEventArgs args(this);
onSizingSettingChanged(args);
}
}
bool SingleLineField::updateString(const std::u16string &nstr, const Cursor &nc) {
auto str = nstr;
auto c = nc;
auto pos = MIN(str.find(u'\n'), str.find(u'\r'));
if (pos != std::u16string::npos) {
str = str.substr(0, pos);
c = Cursor(str.length(), 0);
releaseInput();
if (_onInput) {
_onInput();
}
return true;
}
return TextField::updateString(str, c);
}
void DragContainer::onMouseButtonUp(MouseEventArgs& e)
{
Window::onMouseButtonUp(e);
if (e.button == LeftButton)
{
if (d_dragging)
{
// fire off event
WindowEventArgs args(this);
onDragEnded(args);
}
// release our capture on the input data
releaseInput();
e.handled = true;
}
}
/*************************************************************************
Set whether this title bar widget will respond to dragging.
*************************************************************************/
void Titlebar::setDraggingEnabled(bool setting)
{
if (d_dragEnabled != setting)
{
d_dragEnabled = setting;
// stop dragging now if the setting has been disabled.
if ((!d_dragEnabled) && d_dragging)
{
releaseInput();
}
// call event handler.
WindowEventArgs args(this);
onDraggingModeChanged(args);
}
}
/*************************************************************************
Handler for cursor pressed events
*************************************************************************/
void ComboDropList::onCursorPressHold(CursorInputEventArgs& e)
{
ListWidget::onCursorPressHold(e);
if (e.source == CIS_Left)
{
if (!isHit(e.position))
{
clearSelections();
releaseInput();
}
else
{
d_armed = true;
}
++e.handled;
}
}
void GLWidget::mousePressEvent(QMouseEvent *event)
{
if(event->buttons() & Qt::RightButton) {
if(mouseGrabbed)
releaseInput();
else {
emit setStatus(tr("Exploration mode: Use W, S, A and D keys to go forward, backward or move sideways"));
grabInput();
}
}
if(event->buttons() & Qt::MidButton) {
camera.reset();
if(!mouseGrabbed) update();
}
lastPos= event->globalPos();
}
/*************************************************************************
Handler for mouse button pressed events
*************************************************************************/
void ComboDropList::onMouseButtonDown(MouseEventArgs& e)
{
Listbox::onMouseButtonDown(e);
if (e.button == LeftButton)
{
if (!isHit(e.position))
{
clearAllSelections();
releaseInput();
}
else
{
d_armed = true;
}
++e.handled;
}
}
/*************************************************************************
Handler for mouse button release events
*************************************************************************/
void MenuItem::onMouseButtonUp(MouseEventArgs& e)
{
// default processing
ItemEntry::onMouseButtonUp(e);
if (e.button == LeftButton)
{
releaseInput();
// was the button released over this window?
// (use mouse position, as e.position in args has been unprojected)
if (!d_popupWasClosed &&
getGUIContext().getRootWindow()->getTargetChildAtPosition(
getGUIContext().getMouseCursor().getPosition()) == this)
{
WindowEventArgs we(this);
onClicked(we);
}
// event was handled by us.
++e.handled;
}
}
status_t AudioPolicyManagerALSA::setDeviceConnectionState(AudioSystem::audio_devices device,
AudioSystem::device_connection_state state,
const char *device_address)
{
LOGV("setDeviceConnectionState() device: %x, state %d, address %s", device, state, device_address);
// connect/disconnect only 1 device at a time
if (AudioSystem::popCount(device) != 1) return BAD_VALUE;
if (strlen(device_address) >= MAX_DEVICE_ADDRESS_LEN) {
LOGE("setDeviceConnectionState() invalid address: %s", device_address);
return BAD_VALUE;
}
// handle output devices
if (AudioSystem::isOutputDevice(device)) {
#ifndef WITH_A2DP
if (AudioSystem::isA2dpDevice(device)) {
LOGE("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
#endif
switch (state)
{
// handle output device connection
case AudioSystem::DEVICE_STATE_AVAILABLE:
if (mAvailableOutputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() connecting device %x", device);
// register new device as available
mAvailableOutputDevices |= device;
#ifdef WITH_A2DP
// handle A2DP device connection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpConnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices &= ~device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
LOGV("setDeviceConnectionState() BT SCO device, address %s", device_address);
// keep track of SCO device address
mScoDeviceAddress = String8(device_address, MAX_DEVICE_ADDRESS_LEN);
#ifdef WITH_A2DP
if (mA2dpOutput != 0 &&
mPhoneState != AudioSystem::MODE_NORMAL) {
mpClientInterface->suspendOutput(mA2dpOutput);
}
#endif
}
}
break;
// handle output device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableOutputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %x", device);
return INVALID_OPERATION;
}
LOGV("setDeviceConnectionState() disconnecting device %x", device);
// remove device from available output devices
mAvailableOutputDevices &= ~device;
#ifdef WITH_A2DP
// handle A2DP device disconnection
if (AudioSystem::isA2dpDevice(device)) {
status_t status = handleA2dpDisconnection(device, device_address);
if (status != NO_ERROR) {
mAvailableOutputDevices |= device;
return status;
}
} else
#endif
{
if (AudioSystem::isBluetoothScoDevice(device)) {
mScoDeviceAddress = "";
#ifdef WITH_A2DP
if (mA2dpOutput != 0 &&
mPhoneState != AudioSystem::MODE_NORMAL) {
mpClientInterface->restoreOutput(mA2dpOutput);
}
#endif
}
}
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
// request routing change if necessary
uint32_t newDevice = getNewDevice(mHardwareOutput, false);
// force routing if device disconnection occurs when stream is stopped
if ((newDevice == 0) && (state == AudioSystem::DEVICE_STATE_UNAVAILABLE))
newDevice = getDeviceForStrategy(STRATEGY_MEDIA, false);
#ifdef WITH_A2DP
//+++ KBNAM_PORTING
/* org
checkOutputForAllStrategies(newDevice);
*/
checkOutputForAllStrategies();
//---
// A2DP outputs must be closed after checkOutputForAllStrategies() is executed
if (state == AudioSystem::DEVICE_STATE_UNAVAILABLE && AudioSystem::isA2dpDevice(device)) {
closeA2dpOutputs();
}
#endif
updateDeviceForStrategy();
setOutputDevice(mHardwareOutput, newDevice);
if (device == AudioSystem::DEVICE_OUT_WIRED_HEADSET) {
device = AudioSystem::DEVICE_IN_WIRED_HEADSET;
} else if (device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET ||
device == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT) {
device = AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
} else {
return NO_ERROR;
}
}
// handle input devices
if (AudioSystem::isInputDevice(device)) {
switch (state)
{
// handle input device connection
case AudioSystem::DEVICE_STATE_AVAILABLE: {
if (mAvailableInputDevices & device) {
LOGW("setDeviceConnectionState() device already connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices |= device;
}
break;
// handle input device disconnection
case AudioSystem::DEVICE_STATE_UNAVAILABLE: {
if (!(mAvailableInputDevices & device)) {
LOGW("setDeviceConnectionState() device not connected: %d", device);
return INVALID_OPERATION;
}
mAvailableInputDevices &= ~device;
} break;
default:
LOGE("setDeviceConnectionState() invalid state: %x", state);
return BAD_VALUE;
}
audio_io_handle_t activeInput = getActiveInput();
if (activeInput != 0) {
AudioInputDescriptor *inputDesc = mInputs.valueFor(activeInput);
uint32_t newDevice = getDeviceForInputSource(inputDesc->mInputSource);
if (newDevice != inputDesc->mDevice) {
LOGV("setDeviceConnectionState() changing device from %x to %x for input %d",
inputDesc->mDevice, newDevice, activeInput);
inputDesc->mDevice = newDevice;
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
mpClientInterface->setParameters(activeInput, param.toString());
}
}
else {
/* LGE_CHANGE_S [email protected] 2010.01.27 */
#ifdef SUPPORT_FM_ANALOG
if (device == AudioSystem::DEVICE_IN_FM_ANALOG) {
routing_strategy strategy = getStrategy((AudioSystem::stream_type)3);
uint32_t curOutdevice = getDeviceForStrategy(strategy);
/* If A2DP headset is connected then route FM to Headset */
if (curOutdevice == AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP ||
curOutdevice == AudioSystem::DEVICE_OUT_BLUETOOTH_SCO) {
curOutdevice = AudioSystem::DEVICE_OUT_WIRED_HEADSET;
}
if (state) {
// routing_strategy strategy = getStrategy((AudioSystem::stream_type)3);
// uint32_t curOutdevice = getDeviceForStrategy(strategy);
/* Get the new input descriptor for FM Rx In */
mfmInput = getFMInput(AUDIO_SOURCE_FM_ANALOG,8000,1,
AudioSystem::CHANNEL_IN_MONO,(AudioSystem::audio_in_acoustics)7);
/* Forcely open the current output device again for
* FM Rx playback path to open
*/
LOGV("curOutdevice = %x",curOutdevice);
setOutputDevice(mHardwareOutput, curOutdevice, true);
/* Tell the audio flinger playback thread that
* FM Rx is active
*/
mpClientInterface->setFMRxActive(true);
} else {
int newDevice=0;
AudioParameter param = AudioParameter();
param.addInt(String8(AudioParameter::keyRouting), (int)newDevice);
/* Change the input device from FM to default before releasing Input */
mpClientInterface->setParameters(mfmInput, param.toString());
param.addInt(String8("fm_off"), (int)newDevice);
/* Close the capture handle */
mpClientInterface->setParameters(mfmInput, param.toString());
/* Release the input descriptor for FM Rx In */
releaseInput(mfmInput);
/* Close the playback handle */
mpClientInterface->setParameters(mHardwareOutput, param.toString());
/* Tell the audio flinger playback thread that
* FM Rx is not active now.
*/
mpClientInterface->setFMRxActive(false);
}
}
#endif // SUPPORT_FM_ANALOG
/* LGE_CHANGE_E [email protected] 2010.01.27 */
}
return NO_ERROR;
}
LOGW("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
status_t BnAudioPolicyService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch (code) {
case SET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast <audio_devices_t>(data.readInt32());
audio_policy_dev_state_t state =
static_cast <audio_policy_dev_state_t>(data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
state,
device_address)));
return NO_ERROR;
} break;
case GET_DEVICE_CONNECTION_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_devices_t device =
static_cast<audio_devices_t> (data.readInt32());
const char *device_address = data.readCString();
reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
device_address)));
return NO_ERROR;
} break;
case SET_PHONE_STATE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
reply->writeInt32(static_cast <uint32_t>(setPhoneState(
(audio_mode_t) data.readInt32())));
return NO_ERROR;
} break;
case SET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
audio_policy_forced_cfg_t config =
static_cast <audio_policy_forced_cfg_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
return NO_ERROR;
} break;
case GET_FORCE_USE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
data.readInt32());
reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
return NO_ERROR;
} break;
case GET_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
audio_output_flags_t flags =
static_cast <audio_output_flags_t>(data.readInt32());
audio_io_handle_t output = getOutput(stream,
samplingRate,
format,
channelMask,
flags);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case START_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(startOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case STOP_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
uint32_t stream = data.readInt32();
int session = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(stopOutput(output,
(audio_stream_type_t)stream,
session)));
return NO_ERROR;
} break;
case RELEASE_OUTPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t output = static_cast <audio_io_handle_t>(data.readInt32());
releaseOutput(output);
return NO_ERROR;
} break;
case GET_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t inputSource = (audio_source_t) data.readInt32();
uint32_t samplingRate = data.readInt32();
audio_format_t format = (audio_format_t) data.readInt32();
audio_channel_mask_t channelMask = data.readInt32();
int audioSession = data.readInt32();
audio_io_handle_t input = getInput(inputSource,
samplingRate,
format,
channelMask,
audioSession);
reply->writeInt32(static_cast <int>(input));
return NO_ERROR;
} break;
case START_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(startInput(input)));
return NO_ERROR;
} break;
case STOP_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(stopInput(input)));
return NO_ERROR;
} break;
case RELEASE_INPUT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_io_handle_t input = static_cast <audio_io_handle_t>(data.readInt32());
releaseInput(input);
return NO_ERROR;
} break;
case INIT_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int indexMin = data.readInt32();
int indexMax = data.readInt32();
reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
return NO_ERROR;
} break;
case SET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
int index = data.readInt32();
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
index,
device)));
return NO_ERROR;
} break;
case GET_STREAM_VOLUME: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
int index;
status_t status = getStreamVolumeIndex(stream, &index, device);
reply->writeInt32(index);
reply->writeInt32(static_cast <uint32_t>(status));
return NO_ERROR;
} break;
case GET_STRATEGY_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(getStrategyForStream(stream));
return NO_ERROR;
} break;
case GET_DEVICES_FOR_STREAM: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream =
static_cast <audio_stream_type_t>(data.readInt32());
reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
return NO_ERROR;
} break;
case GET_OUTPUT_FOR_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t output = getOutputForEffect(&desc);
reply->writeInt32(static_cast <int>(output));
return NO_ERROR;
} break;
case REGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
effect_descriptor_t desc;
data.read(&desc, sizeof(effect_descriptor_t));
audio_io_handle_t io = data.readInt32();
uint32_t strategy = data.readInt32();
int session = data.readInt32();
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(registerEffect(&desc,
io,
strategy,
session,
id)));
return NO_ERROR;
} break;
case UNREGISTER_EFFECT: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
return NO_ERROR;
} break;
case SET_EFFECT_ENABLED: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int id = data.readInt32();
bool enabled = static_cast <bool>(data.readInt32());
reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActive((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_STREAM_ACTIVE_REMOTELY: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
uint32_t inPastMs = (uint32_t)data.readInt32();
reply->writeInt32( isStreamActiveRemotely((audio_stream_type_t) stream, inPastMs) );
return NO_ERROR;
} break;
case IS_SOURCE_ACTIVE: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
audio_source_t source = (audio_source_t) data.readInt32();
reply->writeInt32( isSourceActive(source));
return NO_ERROR;
}
case QUERY_DEFAULT_PRE_PROCESSING: {
CHECK_INTERFACE(IAudioPolicyService, data, reply);
int audioSession = data.readInt32();
uint32_t count = data.readInt32();
uint32_t retCount = count;
effect_descriptor_t *descriptors =
(effect_descriptor_t *)new char[count * sizeof(effect_descriptor_t)];
status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
reply->writeInt32(status);
if (status != NO_ERROR && status != NO_MEMORY) {
retCount = 0;
}
reply->writeInt32(retCount);
if (retCount) {
if (retCount < count) {
count = retCount;
}
reply->write(descriptors, sizeof(effect_descriptor_t) * count);
}
delete[] descriptors;
return status;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
