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); } }