alien-everywhere/shimming/alienaudioservice/alienaudio-shim.py

1058 lines
35 KiB
Python
Raw Permalink Normal View History

2023-12-20 10:44:46 +00:00
#!/usr/bin/python
from __future__ import annotations
import asyncio
from dataclasses import dataclass
from enum import IntEnum, IntFlag
import logging
from typing import Any, Callable, Coroutine, Optional
from sdbus import (
DbusInterfaceCommonAsync,
dbus_method_async,
dbus_signal_async,
get_current_message,
sd_bus_open_system,
)
import pulsectl
import pulsectl_asyncio
# Resource policy manager D-BUS parameters
POLICY_DBUS_SERVICE = "org.maemo.resource.manager"
POLICY_DBUS_PATH = "/org/maemo/resource/manager"
POLICY_DBUS_INTERFACE = "org.maemo.resource.manager"
CLIENT_DBUS_INTERFACE = "org.maemo.resource.client"
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger(__name__)
class Client(DbusInterfaceCommonAsync, interface_name=CLIENT_DBUS_INTERFACE):
@dbus_method_async("iuuu", method_name="advice")
async def advice(self, type: int, id: int, reqno: int, resources: int) -> None:
raise NotImplementedError
@dbus_method_async("iuuu", method_name="grant")
async def grant(self, type: int, id: int, reqno: int, resources: int) -> None:
raise NotImplementedError
@dataclass
class Resource:
mandatory: int
optional: int
dbus: Client
is_alien_call: bool = False
class DummyPolicyDaemon(DbusInterfaceCommonAsync, interface_name=POLICY_DBUS_INTERFACE):
def __init__(self, routeManager: RouteManagerShim) -> None:
super().__init__()
self.route_manager = routeManager
self.background_tasks: set[asyncio.Task[None]] = set()
self.granted = True
self.clients: dict[str, dict[str, Resource]] = {}
def path(self, id: int) -> str:
return f"/org/maemo/resource/client{id}"
async def advice(self, sender: str, id: int, reqno: int, resources: int) -> None:
type = 6
print("")
print("ADVICE")
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("resources:", str(resources))
path = self.path(id)
if sender in self.clients:
if path in self.clients[sender]:
resource = self.clients[sender][path]
try:
await resource.dbus.advice(type, id, reqno, resources)
log.info("Reply")
except:
log.exception("Something went wrong")
async def grant(self, sender: str, id: int, reqno: int, resources: int) -> None:
type = 5
print("")
print("GRANT")
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("resources:", str(resources))
path = self.path(id)
if sender in self.clients:
if path in self.clients[sender]:
resource = self.clients[sender][path]
try:
await resource.dbus.grant(type, id, reqno, resources)
except:
log.exception("Something went wrong")
def idle_response(
self,
func: Callable[[str, int, int, int], Coroutine[None, None, None]],
sender: str,
id: int,
reqno: int,
resources: int,
) -> None:
async def wrap() -> None:
await asyncio.sleep(1)
await func(sender, id, reqno, resources)
task = asyncio.create_task(wrap())
task.add_done_callback(self.background_tasks.discard)
self.background_tasks.add(task)
@dbus_method_async("iuuuuuussu", "iuuis", method_name="register")
async def register(
self,
type: int,
id: int,
reqno: int,
mandatory: int,
optional: int,
share: int,
mask: int,
app_id: str,
klass: str,
mode: int,
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("REGISTER", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("mandatory:", str(mandatory))
print("optional: ", str(optional))
print("share: ", str(share))
print("mask: ", str(mask))
print("app_id: ", app_id)
print("class: ", klass)
print("mode: ", str(mode))
client = {}
if sender in self.clients:
client = self.clients[sender]
path = self.path(id)
assert sender is not None
proxy = Client.new_proxy(sender, path, bus=sd_bus_open_system())
resource = Resource(mandatory, optional, proxy)
client[path] = resource
self.clients[sender] = client
self.idle_response(self.advice, sender, id, reqno, resource.mandatory)
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
@dbus_method_async("iuuuuuussu", "iuuis", method_name="update")
async def update(
self,
type: int,
id: int,
reqno: int,
mandatory: int,
optional: int,
share: int,
mask: int,
app_id: str,
klass: str,
mode: int,
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("UPDATE", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("mandatory:", str(mandatory))
print("optional: ", str(optional))
print("share: ", str(share))
print("mask: ", str(mask))
print("app_id: ", app_id)
print("class: ", klass)
print("mode: ", str(mode))
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
@dbus_method_async("iuu", "iuuis", method_name="acquire")
async def acquire(
self, type: int, id: int, reqno: int
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("ACQUIRE", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
assert sender is not None
# find the client
resource = self.clients[sender][self.path(id)]
if resource.is_alien_call:
log.info("switching to call mode")
# subprocess.run(['callaudiocli', '-m', '1'])
await self.route_manager.route_output_for_call(True)
self.idle_response(self.grant, sender, id, reqno, resource.mandatory)
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
@dbus_method_async("iuu", "iuuis", method_name="release")
async def release(
self, type: int, id: int, reqno: int
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("RELEASE", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
assert sender is not None
self.idle_response(self.grant, sender, id, reqno, 0)
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
@dbus_method_async("iuu", "iuuis", method_name="unregister")
async def unregister(
self, type: int, id: int, reqno: int
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
errorCode = 0
errorString = "OK"
print("")
print("UNREGISTER", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
assert sender is not None
client = self.clients[sender]
path = self.path(id)
resource = client[path]
if resource.is_alien_call:
log.info("switching back from call mode")
# subprocess.run(['callaudiocli', '-m', '0'])
await self.route_manager.route_output_for_call(False)
del client[path]
if len(client) == 0:
del self.clients[sender]
return (9, id, reqno, errorCode, errorString)
except:
log.exception('')
@dbus_method_async("iuusssis", "iuuis", method_name="audio")
async def audio(
self,
type: int,
id: int,
reqno: int,
group: str,
pid: str,
streamName: str,
method: int,
pattern: str,
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("AUDIO", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("group: ", group)
print("pid: ", pid)
print("stream name:", streamName)
# typedef enum {
# resmsg_method_equals = 0,
# resmsg_method_startswith,
# resmsg_method_matches
# } resmsg_match_method_t;
print("method: ", str(method))
print("pattern: ", pattern)
assert sender is not None
resource = self.clients[sender][self.path(id)]
if streamName == "media.name" and method == 0 and pattern == "voice":
log.info("detected voice call, will switch devices on acquire()")
resource.is_alien_call = True
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
@dbus_method_async("iuuu", "iuuis", method_name="video")
async def video(
self, type: int, id: int, reqno: int, pid: int
) -> tuple[int, int, int, int, str]:
try:
sender = get_current_message().sender
error_code = 0
error_string = "OK"
print("")
print("VIDEO", sender)
print("type: ", str(type))
print("id: ", str(id))
print("reqno: ", str(reqno))
print("pid: ", str(pid))
return (9, id, reqno, error_code, error_string)
except:
log.exception('')
class AudioOutputRoute(IntEnum):
EARPIECE = 1
PHONE_SPEAKER = 2
EXTERNAL_SPEAKER = 3
HEADPHONE = 4
class OhmRouteType(IntFlag):
OUTPUT = 1 << 0 # sink
INPUT = 1 << 1 # source
BUILTIN = 1 << 2
WIRED = 1 << 3
WIRELESS = 1 << 4
VOICE = 1 << 5
BLUETOOTH_SCO = 1 << 6
BLUETOOTH_A2DP = 1 << 7
HEADSET = 1 << 8
HEADPHONE = 1 << 9
USB = 1 << 10
UNKNOWN = 1 << 11
AVAILABLE = 1 << 25
PREFERRED = 1 << 26
ACTIVE = 1 << 27
class RouteManagerShim(
DbusInterfaceCommonAsync, interface_name="org.nemomobile.Route.Manager"
):
def __init__(self, pulse: pulsectl_asyncio.PulseAsync) -> None:
super().__init__()
self.pulse = pulse
self.output_route_before_call: Optional[
tuple[pulsectl.PulseSinkInfo, pulsectl.PulsePortInfo]
] = None
self.output_route_before_speaker: Optional[
tuple[pulsectl.PulseSinkInfo, pulsectl.PulsePortInfo]
] = None
self.input_route_before_speaker: Optional[
tuple[pulsectl.PulseSourceInfo, pulsectl.PulsePortInfo]
] = None
self.background_tasks: set[asyncio.Task[None]] = set()
async def listen() -> None:
async for event in self.pulse.subscribe_events('all'):
if event.t == "change":
log.info("pulse event happend")
await self.mce.sync_proximity_monitoring()
task = asyncio.create_task(listen())
task.add_done_callback(self.background_tasks.discard)
self.background_tasks.add(task)
# register signal handlers to cancel listener when program is asked to terminate
# Alternatively, the PulseAudio event subscription can be ended by breaking/returning from the `async for` loop
# for sig in (signal.SIGTERM, signal.SIGHUP, signal.SIGINT):
# loop.add_signal_handler(sig, task.cancel)
async def _sink_list(self) -> list[pulsectl.PulseSinkInfo]:
sinks = await self.pulse.sink_list()
assert isinstance(sinks, list)
return sinks
async def _source_list(self) -> list[pulsectl.PulseSourceInfo]:
sources = await self.pulse.source_list()
assert isinstance(sources, list)
return sources
@dbus_method_async("s", method_name="Enable")
async def enable(self, route: str) -> None:
try:
log.info("route enable: %s", route)
if route == "speaker":
await self.use_speaker_in_call(True)
except:
log.exception('')
@dbus_method_async("s", method_name="Disable")
async def disable(self, route: str) -> None:
try:
log.info("route disable: %s", route)
if route == "speaker":
await self.use_speaker_in_call(False)
except:
log.exception('')
@dbus_method_async(result_signature="susu", method_name="ActiveRoutes")
async def active_routes(self) -> tuple[str, int, str, int]:
try:
OHM_EXT_ROUTE_TYPE_OUTPUT = 1 << 0 # sink
OHM_EXT_ROUTE_TYPE_INPUT = 1 << 1 # source
OHM_EXT_ROUTE_TYPE_BUILTIN = 1 << 2
OHM_EXT_ROUTE_TYPE_WIRED = 1 << 3
OHM_EXT_ROUTE_TYPE_WIRELESS = 1 << 4
OHM_EXT_ROUTE_TYPE_VOICE = 1 << 5
OHM_EXT_ROUTE_TYPE_BLUETOOTH_SCO = 1 << 6
OHM_EXT_ROUTE_TYPE_BLUETOOTH_A2DP = 1 << 7
OHM_EXT_ROUTE_TYPE_HEADSET = 1 << 8
OHM_EXT_ROUTE_TYPE_HEADPHONE = 1 << 9
OHM_EXT_ROUTE_TYPE_USB = 1 << 10
OHM_EXT_ROUTE_TYPE_UNKNOWN = 1 << 11
OHM_EXT_ROUTE_TYPE_AVAILABLE = 1 << 25
OHM_EXT_ROUTE_TYPE_PREFERRED = 1 << 26
OHM_EXT_ROUTE_TYPE_ACTIVE = 1 << 27
routes = (
"speaker",
OHM_EXT_ROUTE_TYPE_OUTPUT
| OHM_EXT_ROUTE_TYPE_BUILTIN
| OHM_EXT_ROUTE_TYPE_AVAILABLE
| OHM_EXT_ROUTE_TYPE_ACTIVE,
"microphone",
OHM_EXT_ROUTE_TYPE_INPUT | OHM_EXT_ROUTE_TYPE_BUILTIN,
)
log.info("ActiveRoutes: %s", routes)
return routes
except:
log.exception('')
@dbus_signal_async("su", signal_name="AudioRouteChanged")
async def audio_route_changed(self) -> None:
raise NotImplementedError
def audio_route_changed_emit(self, name: str, type: OhmRouteType) -> None:
# fairly certain the checker is wrong here
self.audio_route_changed.emit((name, int(type))) # type: ignore
@dbus_signal_async("suu", signal_name="AudioFeatureChanged")
async def audio_feature_changed(self) -> None:
raise NotImplementedError
def audio_feature_changed_emit(self, name: str, a: bool, b: bool) -> None:
# fairly certain the checker is wrong here
self.audio_feature_changed.emit((name, int(a), int(b))) # type: ignore
async def get_default_sink(self) -> pulsectl.PulseSinkInfo:
sink_name = (await self.pulse.server_info()).default_sink_name
for sink in await self._sink_list():
if sink.name == sink_name:
return sink
raise Exception("No default sink found")
async def get_default_source(self) -> pulsectl.PulseSourceInfo:
source_name = (await self.pulse.server_info()).default_source_name
for source in await self._source_list():
if source.name == source_name:
return source
raise Exception("No default source found")
async def find_private_output_for_call(
self,
) -> tuple[pulsectl.PulseSinkInfo, pulsectl.PulsePortInfo]:
# first try active sink
sink = await self.get_default_sink()
for port in sink.port_list:
if port.available != "no" and port.type == "headphones":
return (sink, port)
if port.available != "no" and port.type == "earpiece":
return (sink, port)
# now try all sinks (these don't have priorities)
for sink in await self._sink_list():
# ports should be ordered by priority already
for port in sink.port_list:
if port.available != "no" and port.type == "headphones":
return (sink, port)
if port.available != "no" and port.type == "earpiece":
return (sink, port)
log.info("no earpiece found")
raise Exception("No earpiece found")
async def find_mic_for_output(
self,
sink: pulsectl.PulseSinkInfo,
port: pulsectl.PulsePortInfo,
) -> tuple[pulsectl.PulseSourceInfo, pulsectl.PulsePortInfo]:
# look for mic on same device as the output
sink_device = sink.name.split('.')[1]
log.info("looking at output dev: %s", sink_device)
searching_for_type = "mic"
for source in await self._source_list():
device = source.name.split('.')[1]
if device == sink_device:
for source_port in source.port_list:
if source_port.available != "no" and source_port.type == searching_for_type:
return (source, source_port)
return (None, None)
async def find_best_output(
self,
) -> tuple[pulsectl.PulseSinkInfo, pulsectl.PulsePortInfo]:
# first try the highest priority port on the current sink
sink = await self.get_default_sink()
for port in sink.port_list:
if port.available != "no":
return (sink, port)
# now try other sinks (these don't have priorities)
for sink in await self._sink_list():
for port in sink.port_list:
if port.available != "no":
return (sink, port)
raise Exception("No best output found")
async def find_speaker_for_call(
self,
) -> tuple[pulsectl.PulseSinkInfo, pulsectl.PulsePortInfo]:
# if route before call happened to be speaker, use that
if self.output_route_before_call is not None:
(sink, port) = self.output_route_before_call
if await self.route_still_exists(sink, port):
if port.available != "no" and port.type == "speaker":
return (sink, port)
# otherwise look for a speaker on current sink
sink = await self.get_default_sink()
for port in sink.port_list:
if port.available != "no" and port.type == "speaker":
return (sink, port)
# otherwise try all sinks (these don't have priorities)
for sink in await self._sink_list():
# ports should be ordered by priority already
for port in sink.port_list:
if port.available != "no" and port.type == "speaker":
return (sink, port)
log.info("no speaker found")
raise Exception("No speaker found")
async def route_still_exists(
self,
existing_sink: pulsectl.PulseSinkInfo,
existing_port: pulsectl.PulsePortInfo,
) -> bool:
log.info("checking if route still exists")
for sink in await self._sink_list():
if sink.name != existing_sink.name:
continue
for port in sink.port_list:
if port.name == existing_port.name and port.available != "no":
print("yupppp")
return True
log.info("that's a no")
return False
async def source_route_still_exists(
self,
existing_source: pulsectl.PulseSourceInfo,
existing_port: pulsectl.PulsePortInfo,
) -> bool:
log.info("checking if route still exists")
for source in await self._source_list():
if source.name != existing_source.name:
continue
for port in source.port_list:
if port.name == existing_port.name and port.available != "no":
print("yupppp")
return True
log.info("that's a no")
return False
async def switch_output(
self,
sink: pulsectl.PulseSinkInfo,
port: pulsectl.PulsePortInfo,
) -> None:
default_sink = await self.get_default_sink()
if sink.name != default_sink.name:
print("need to switch sink")
await self.pulse.default_set(sink)
for sink_input in await self.pulse.sink_input_list():
print("moving stream over to new sink")
await self.pulse.sink_input_move(sink_input.index, sink.index)
if len(sink.port_list) > 1:
await self.pulse.port_set(sink, port)
async def switch_input(
self,
source: pulsectl.PulseSourceInfo,
port: pulsectl.PulsePortInfo,
) -> None:
default_source = await self.get_default_source()
if source.name != default_source.name:
print("need to switch source")
await self.pulse.default_set(source)
for source_output in await self.pulse.source_output_list():
print("moving stream over to new source")
await self.pulse.source_output_move(source_output.index, source.index)
if len(source.port_list) > 1:
await self.pulse.port_set(source, port)
async def route_output_for_call(self, in_call: bool) -> None:
log.info("routeOutputForCall %r", in_call)
default_sink = await self.get_default_sink()
log.info("cur route %s", default_sink.port_active.name)
if in_call:
# if any speaker (could also be bt) is in use, switch to a more
# private device (earpiece or headphones), otherwise just leave
# things as-is
if default_sink.port_active.type == "speaker":
self.output_route_before_call = (default_sink, default_sink.port_active)
(sink, port) = await self.find_private_output_for_call()
await self.switch_output(sink, port)
self.audio_route_changed_emit(
"speaker",
OhmRouteType.OUTPUT | OhmRouteType.BUILTIN | OhmRouteType.AVAILABLE,
)
self.audio_route_changed_emit(
"earpiece",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.VOICE
| OhmRouteType.AVAILABLE
| OhmRouteType.ACTIVE,
)
self.audio_feature_changed_emit("speaker", True, False)
else:
if default_sink.port_active.type == "earpiece":
if self.output_route_before_call is not None:
log.info("Restoring output route from before call")
(sink, prev_port) = self.output_route_before_call
if not await self.route_still_exists(sink, prev_port):
log.info("Route no longer exists, finding new one")
(sink, prev_port) = await self.find_best_output()
else:
(sink, prev_port) = await self.find_best_output()
await self.switch_output(sink, prev_port)
if self.input_route_before_speaker is not None:
log.info("Restoring input route from before call")
(source, prev_port) = self.input_route_before_speaker
if await self.source_route_still_exists(source, prev_port):
await self.switch_input(source, prev_port)
else:
log.info("Route no longer exists, not restoring")
self.output_route_before_call = None
self.output_route_before_speaker = None
self.input_route_before_speaker = None
log.info("new route: %s", (await self.get_default_sink()).port_active.name)
await self.mce.sync_proximity_monitoring()
async def use_speaker_in_call(self, use_speaker: bool) -> None:
log.info("useSpeakerInCall %r", use_speaker)
default_sink = await self.get_default_sink()
log.info("cur route %s", default_sink.port_active.name)
if use_speaker:
if default_sink.port_active.type != "speaker":
self.output_route_before_speaker = (default_sink, default_sink.port_active)
(sink, port) = await self.find_speaker_for_call()
await self.switch_output(sink, port)
default_source = await self.get_default_source()
if default_source.port_active.type != "mic":
(source, port) = await self.find_mic_for_output(sink, port)
if source != None:
log.info("Found an internal mic, switching")
self.input_route_before_speaker = (default_source, default_source.port_active)
await self.switch_input(source, port)
self.audio_route_changed_emit(
"earpiece",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.VOICE
| OhmRouteType.AVAILABLE,
)
self.audio_route_changed_emit(
"speaker",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.AVAILABLE
| OhmRouteType.ACTIVE,
)
self.audio_feature_changed_emit("speaker", True, True)
else:
# we're not listening to sink/port changes from pulse,
# so if output changed to a speaker underneath our feet, just change the route silently
self.audio_route_changed_emit(
"earpiece",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.VOICE
| OhmRouteType.AVAILABLE,
)
self.audio_route_changed_emit(
"speaker",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.AVAILABLE
| OhmRouteType.ACTIVE,
)
self.audio_feature_changed_emit("speaker", True, True)
else:
if default_sink.port_active.type == "speaker":
if self.output_route_before_speaker is not None:
log.info("Restoring output route from before speaker")
(sink, prev_port) = self.output_route_before_speaker
if not await self.route_still_exists(sink, prev_port):
log.info("Route no longer exists, finding new one")
(sink, prev_port) = await self.find_private_output_for_call()
else:
(sink, prev_port) = await self.find_private_output_for_call()
await self.switch_output(sink, prev_port)
if self.input_route_before_speaker is not None:
log.info("Restoring input route from before speaker")
(source, prev_port) = self.input_route_before_speaker
if await self.source_route_still_exists(source, prev_port):
await self.switch_input(source, prev_port)
else:
log.info("Route no longer exists, not restoring")
self.audio_route_changed_emit(
"speaker",
OhmRouteType.OUTPUT | OhmRouteType.BUILTIN | OhmRouteType.AVAILABLE,
)
self.audio_route_changed_emit(
"earpiece",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.VOICE
| OhmRouteType.AVAILABLE
| OhmRouteType.ACTIVE,
)
self.audio_feature_changed_emit("speaker", True, False)
else:
# we're not listening to sink/port changes from pulse,
# so if output changed to a speaker underneath our feet, just change the route silently
self.audio_route_changed_emit(
"speaker",
OhmRouteType.OUTPUT | OhmRouteType.BUILTIN | OhmRouteType.AVAILABLE,
)
self.audio_route_changed_emit(
"earpiece",
OhmRouteType.OUTPUT
| OhmRouteType.BUILTIN
| OhmRouteType.VOICE
| OhmRouteType.AVAILABLE
| OhmRouteType.ACTIVE,
)
self.audio_feature_changed_emit("speaker", True, False)
self.output_route_before_speaker = None
self.input_route_before_speaker = None
log.info("new route: %s", (await self.get_default_sink()).port_active.name)
await self.mce.sync_proximity_monitoring()
async def is_routing_to_earpiece(self) -> bool:
default_sink = await self.get_default_sink()
return default_sink.port_active.type == "earpiece"
def set_mce(self, mce: MceShim) -> bool:
self.mce = mce
class SensorDaemon(DbusInterfaceCommonAsync, interface_name="org.gnome.Shell.SensorDaemon"):
@dbus_method_async(method_name="StartProximityMonitoring")
async def start_proximity_monitoring() -> None:
raise NotImplementedError
@dbus_method_async(method_name="StopProximityMonitoring")
async def stop_proximity_monitoring() -> None:
raise NotImplementedError
class MceShim(DbusInterfaceCommonAsync, interface_name="com.nokia.mce.request"):
def __init__(self, route_manager: RouteManagerShim) -> None:
super().__init__()
self.route_manager = route_manager
self.sensor_daemon = SensorDaemon.new_proxy(
"org.gnome.Shell.SensorDaemon", "/org/gnome/Shell/SensorDaemon"
)
self.in_call = False
self.monitoring_proximity = False
async def sync_proximity_monitoring(self) -> None:
should_monitor = self.in_call and await self.route_manager.is_routing_to_earpiece()
log.info("sync moni %d", should_monitor)
if should_monitor != self.monitoring_proximity:
self.monitoring_proximity = should_monitor
if should_monitor:
await self.sensor_daemon.start_proximity_monitoring()
else:
await self.sensor_daemon.stop_proximity_monitoring()
@dbus_method_async("ss", "b", method_name="req_call_state_change")
async def req_call_state_change(self, state: str, desc: str) -> bool:
try:
log.info("req_call_state_change: %s", state)
if state == "active":
self.in_call = True
elif state == "none":
self.in_call = False
await self.sync_proximity_monitoring()
return True
except:
log.exception('')
class Feedbackd(DbusInterfaceCommonAsync, interface_name="org.sigxcpu.Feedback"):
@dbus_method_async("ssa{sv}i", "u", method_name="TriggerFeedback")
async def trigger_feedback(
self, app_id: str, event: str, hints: dict[str, Any], timeout: int
) -> int:
raise NotImplementedError
@dbus_method_async("u", method_name="EndFeedback")
async def end_feedback(self, id: int) -> None:
raise NotImplementedError
class NonGraphicFeedbackShim(
DbusInterfaceCommonAsync, interface_name="com.nokia.NonGraphicFeedback1"
):
def __init__(self) -> None:
super().__init__()
self.feedbackd = Feedbackd.new_proxy(
"org.sigxcpu.Feedback", "/org/sigxcpu/Feedback"
)
self.current_id = -1
def translate_feedback(
self, name: str, params: dict[str, Any]
) -> tuple[str, dict[str, Any]]:
hints = {}
feedbackName = None
if name == "feedback_press":
# generic touch feedback
feedbackName = "button-pressed"
elif name == "pulldown_highlight":
# another generic touch feedback
feedbackName = "button-pressed"
elif name == "vibra":
# only vibration feedback, no sound
feedbackName = "bell-terminal"
hints["profile"] = ("s", "quiet")
if 'media.vibra' in params:
should_vibrate = params['media.vibra'][1]
if not should_vibrate:
# unfortunately we can only disable vibration by also disabling sound
hints["profile"] = ("s", "silent")
if 'haptic.sequence' in params:
haptic_sequence = params['haptic.sequence'][1]
# in format "on=timeMs"
if 'haptic.type' in params:
haptic_type = params['haptic.type'][1]
# can be "touch"
return (feedbackName, hints)
@dbus_method_async("sa{sv}", "u", method_name="Play")
async def play(self, name: str, params: dict[str, Any]) -> int:
try:
log.info("NonGraphicFeedbackShim Play: %s", name)
print(params)
(feedback_name, hints) = self.translate_feedback(name, params)
if feedback_name == None:
return 0
print("NonGraphicFeedbackShim actually playing:", feedback_name, hints)
self.current_id = await self.feedbackd.trigger_feedback(
"aliendalvik", feedback_name, hints, -1
)
return self.current_id
except:
log.exception('')
@dbus_method_async("u", "u", method_name="Stop")
async def stop(self, feedback_id: int) -> int:
try:
log.info("NonGraphicFeedbackShim Stop: %i", feedback_id)
await self.feedbackd.end_feedback(feedback_id)
self.current_id = -1
return 0
except:
log.exception('')
async def main() -> None:
system = sd_bus_open_system()
await asyncio.gather(
*(
system.request_name_async(name, 0)
for name in [
POLICY_DBUS_SERVICE,
"com.nokia.NonGraphicFeedback1.Backend",
"org.nemomobile.Route.Manager",
"com.nokia.mce",
]
)
)
async with pulsectl_asyncio.PulseAsync("my-client-name") as pulse:
log.info("sinks: %r", await pulse.sink_list())
route_manager = RouteManagerShim(pulse)
route_manager.export_to_dbus("/org/nemomobile/Route/Manager", system)
call_daemon = DummyPolicyDaemon(route_manager)
call_daemon.export_to_dbus(POLICY_DBUS_PATH, system)
mce = MceShim(route_manager)
route_manager.set_mce(mce)
mce.export_to_dbus("/com/nokia/mce/request", system)
ngf = NonGraphicFeedbackShim()
ngf.export_to_dbus("/com/nokia/NonGraphicFeedback1", system)
while True:
await asyncio.sleep(10)
if __name__ == "__main__":
asyncio.run(main())