a485709173
this method will be called by frontend to know which profile to connect automatically (when the frontend has been closed and is reopened, this will avoid to have to go through the profileManager again).
376 lines
13 KiB
Python
376 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# SAT plugin for file tansfer
|
|
# Copyright (C) 2009-2019 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import sys
|
|
import os
|
|
import os.path
|
|
from pathlib import Path
|
|
from sat.core.i18n import _, D_
|
|
from sat.core.constants import Const as C
|
|
from sat.core.log import getLogger
|
|
from sat.core import exceptions
|
|
from sat.memory import params
|
|
from twisted.internet import defer
|
|
from twisted.internet import reactor
|
|
from twisted.internet import protocol
|
|
from twisted.internet import error as int_error
|
|
|
|
log = getLogger(__name__)
|
|
|
|
PLUGIN_INFO = {
|
|
C.PI_NAME: "Android",
|
|
C.PI_IMPORT_NAME: "android",
|
|
C.PI_TYPE: C.PLUG_TYPE_MISC,
|
|
C.PI_RECOMMENDATIONS: ["XEP-0352"],
|
|
C.PI_MAIN: "AndroidPlugin",
|
|
C.PI_HANDLER: "no",
|
|
C.PI_DESCRIPTION: D_(
|
|
"""Manage Android platform specificities, like pause or notifications"""
|
|
),
|
|
}
|
|
|
|
if sys.platform != "android":
|
|
raise exceptions.CancelError("this module is not needed on this platform")
|
|
|
|
|
|
from plyer import notification, vibrator
|
|
from plyer.platforms.android import activity
|
|
from jnius import autoclass
|
|
from android.broadcast import BroadcastReceiver
|
|
|
|
#: delay between a pause event and sending the inactive indication to server, in seconds
|
|
#: we don't send the indication immediately because user can be just checking something
|
|
#: quickly on an other app.
|
|
CSI_DELAY = 30
|
|
|
|
PARAM_RING_CATEGORY = "Notifications"
|
|
PARAM_RING_NAME = "sound"
|
|
PARAM_RING_LABEL = D_("sound on notifications")
|
|
RING_OPTS = {
|
|
"normal": D_("Normal"),
|
|
"never": D_("Never"),
|
|
}
|
|
PARAM_VIBRATE_CATEGORY = "Notifications"
|
|
PARAM_VIBRATE_NAME = "vibrate"
|
|
PARAM_VIBRATE_LABEL = D_("Vibrate on notifications")
|
|
VIBRATION_OPTS = {
|
|
"always": D_("Always"),
|
|
"vibrate": D_("In vibrate mode"),
|
|
"never": D_("Never"),
|
|
}
|
|
SOCKET_DIR = "/data/data/org.salutatoi.cagou/"
|
|
SOCKET_FILE = ".socket"
|
|
STATE_RUNNING = b"running"
|
|
STATE_PAUSED = b"paused"
|
|
STATE_STOPPED = b"stopped"
|
|
STATES = (STATE_RUNNING, STATE_PAUSED, STATE_STOPPED)
|
|
NET_TYPE_NONE = "no network"
|
|
NET_TYPE_WIFI = "wifi"
|
|
NET_TYPE_MOBILE = "mobile"
|
|
NET_TYPE_OTHER = "other"
|
|
|
|
|
|
Context = autoclass('android.content.Context')
|
|
ConnectivityManager = autoclass('android.net.ConnectivityManager')
|
|
MediaPlayer = autoclass('android.media.MediaPlayer')
|
|
AudioManager = autoclass('android.media.AudioManager')
|
|
|
|
|
|
class FrontendStateProtocol(protocol.Protocol):
|
|
|
|
def __init__(self, android_plugin):
|
|
self.android_plugin = android_plugin
|
|
|
|
def dataReceived(self, data):
|
|
if data in STATES:
|
|
self.android_plugin.state = data
|
|
else:
|
|
log.warning("Unexpected data: {data}".format(data=data))
|
|
|
|
|
|
class FrontendStateFactory(protocol.Factory):
|
|
|
|
def __init__(self, android_plugin):
|
|
self.android_plugin = android_plugin
|
|
|
|
def buildProtocol(self, addr):
|
|
return FrontendStateProtocol(self.android_plugin)
|
|
|
|
|
|
|
|
class AndroidPlugin(object):
|
|
|
|
params = """
|
|
<params>
|
|
<individual>
|
|
<category name="{category_name}" label="{category_label}">
|
|
<param name="{ring_param_name}" label="{ring_param_label}" type="list" security="0">
|
|
{ring_options}
|
|
</param>
|
|
<param name="{vibrate_param_name}" label="{vibrate_param_label}" type="list" security="0">
|
|
{vibrate_options}
|
|
</param>
|
|
</category>
|
|
</individual>
|
|
</params>
|
|
""".format(
|
|
category_name=PARAM_VIBRATE_CATEGORY,
|
|
category_label=D_(PARAM_VIBRATE_CATEGORY),
|
|
vibrate_param_name=PARAM_VIBRATE_NAME,
|
|
vibrate_param_label=PARAM_VIBRATE_LABEL,
|
|
vibrate_options=params.makeOptions(VIBRATION_OPTS, "always"),
|
|
ring_param_name=PARAM_RING_NAME,
|
|
ring_param_label=PARAM_RING_LABEL,
|
|
ring_options=params.makeOptions(RING_OPTS, "normal"),
|
|
)
|
|
|
|
def __init__(self, host):
|
|
log.info(_("plugin Android initialization"))
|
|
self.host = host
|
|
self._csi = host.plugins.get('XEP-0352')
|
|
self._csi_timer = None
|
|
host.memory.updateParams(self.params)
|
|
try:
|
|
os.mkdir(SOCKET_DIR, 0o700)
|
|
except OSError as e:
|
|
if e.errno == 17:
|
|
# dir already exists
|
|
pass
|
|
else:
|
|
raise e
|
|
self._state = None
|
|
factory = FrontendStateFactory(self)
|
|
socket_path = os.path.join(SOCKET_DIR, SOCKET_FILE)
|
|
try:
|
|
reactor.listenUNIX(socket_path, factory)
|
|
except int_error.CannotListenError as e:
|
|
if e.socketError.errno == 98:
|
|
# the address is already in use, we need to remove it
|
|
os.unlink(socket_path)
|
|
reactor.listenUNIX(socket_path, factory)
|
|
else:
|
|
raise e
|
|
# we set a low priority because we want the notification to be sent after all
|
|
# plugins have done their job
|
|
host.trigger.add("MessageReceived", self.messageReceivedTrigger, priority=-1000)
|
|
|
|
# profiles autoconnection
|
|
host.bridge.addMethod(
|
|
"profileAutoconnectGet",
|
|
".plugin",
|
|
in_sign="",
|
|
out_sign="s",
|
|
method=self._profileAutoconnectGet,
|
|
async_=True,
|
|
)
|
|
|
|
# audio manager, to get ring status
|
|
self.am = activity.getSystemService(Context.AUDIO_SERVICE)
|
|
|
|
# sound notification
|
|
media_dir = Path(host.memory.getConfig("", "media_dir"))
|
|
assert media_dir is not None
|
|
notif_path = media_dir / "sounds" / "notifications" / "music-box.mp3"
|
|
self.notif_player = MediaPlayer()
|
|
self.notif_player.setDataSource(str(notif_path))
|
|
self.notif_player.setAudioStreamType(AudioManager.STREAM_NOTIFICATION)
|
|
self.notif_player.prepare()
|
|
|
|
# Connectivity handling
|
|
self.cm = activity.getSystemService(Context.CONNECTIVITY_SERVICE)
|
|
self._net_type = None
|
|
self._checkConnectivity()
|
|
# XXX: we need to keep a reference to BroadcastReceiver to avoid
|
|
# "XXX has no attribute 'invoke'" error (looks like the same issue as
|
|
# https://github.com/kivy/pyjnius/issues/59)
|
|
self.br = BroadcastReceiver(
|
|
callback=lambda *args, **kwargs: reactor.callLater(0,
|
|
self.onConnectivityChange),
|
|
actions=["android.net.conn.CONNECTIVITY_CHANGE"])
|
|
self.br.start()
|
|
|
|
@property
|
|
def state(self):
|
|
return self._state
|
|
|
|
@state.setter
|
|
def state(self, new_state):
|
|
log.debug(f"frontend state has changed: {new_state.decode()}")
|
|
previous_state = self._state
|
|
self._state = new_state
|
|
if new_state == STATE_RUNNING:
|
|
self._onRunning(previous_state)
|
|
elif new_state == STATE_PAUSED:
|
|
self._onPaused(previous_state)
|
|
elif new_state == STATE_STOPPED:
|
|
self._onStopped(previous_state)
|
|
|
|
@property
|
|
def cagou_active(self):
|
|
return self._state == STATE_RUNNING
|
|
|
|
def _onRunning(self, previous_state):
|
|
if previous_state is not None:
|
|
self.host.bridge.bridgeReactivateSignals()
|
|
self.setActive()
|
|
|
|
def _onPaused(self, previous_state):
|
|
self.host.bridge.bridgeDeactivateSignals()
|
|
self.setInactive()
|
|
|
|
def _onStopped(self, previous_state):
|
|
self.setInactive()
|
|
|
|
def _notifyMessage(self, mess_data, client):
|
|
"""Send notification when suitable
|
|
|
|
notification is sent if:
|
|
- there is a message and it is not a groupchat
|
|
- message is not coming from ourself
|
|
"""
|
|
if (mess_data["message"] and mess_data["type"] != C.MESS_TYPE_GROUPCHAT
|
|
and not mess_data["from"].userhostJID() == client.jid.userhostJID()):
|
|
message = next(iter(mess_data["message"].values()))
|
|
try:
|
|
subject = next(iter(mess_data["subject"].values()))
|
|
except StopIteration:
|
|
subject = "Cagou new message"
|
|
|
|
notification.notify(title=subject, message=message)
|
|
|
|
ringer_mode = self.am.getRingerMode()
|
|
vibrate_mode = ringer_mode == AudioManager.RINGER_MODE_VIBRATE
|
|
|
|
ring_setting = self.host.memory.getParamA(
|
|
PARAM_RING_NAME,
|
|
PARAM_RING_CATEGORY,
|
|
profile_key=client.profile
|
|
)
|
|
|
|
if ring_setting != 'never' and ringer_mode == AudioManager.RINGER_MODE_NORMAL:
|
|
self.notif_player.start()
|
|
|
|
vibration_setting = self.host.memory.getParamA(
|
|
PARAM_VIBRATE_NAME,
|
|
PARAM_VIBRATE_CATEGORY,
|
|
profile_key=client.profile
|
|
)
|
|
if (vibration_setting == 'always'
|
|
or vibration_setting == 'vibrate' and vibrate_mode):
|
|
try:
|
|
vibrator.vibrate()
|
|
except Exception as e:
|
|
log.warning("Can't use vibrator: {e}".format(e=e))
|
|
return mess_data
|
|
|
|
def messageReceivedTrigger(self, client, message_elt, post_treat):
|
|
if not self.cagou_active:
|
|
# we only send notification is the frontend is not displayed
|
|
post_treat.addCallback(self._notifyMessage, client)
|
|
|
|
return True
|
|
|
|
# Profile autoconnection
|
|
|
|
def _profileAutoconnectGet(self):
|
|
return defer.ensureDeferred(self.profileAutoconnectGet())
|
|
|
|
async def profileAutoconnectGet(self):
|
|
"""Return profile to connect automatically by frontend, if any"""
|
|
autoconnect_dict = await self.host.memory.storage.getIndParamValues(
|
|
category='Connection', name='autoconnect_backend',
|
|
)
|
|
profiles_autoconnect = [p for p, v in autoconnect_dict.items() if C.bool(v)]
|
|
if not profiles_autoconnect:
|
|
return None
|
|
if len(profiles_autoconnect) > 1:
|
|
log.warning(
|
|
f"More that one profiles with backend autoconnection set found, picking "
|
|
f"up first one (full list: {profiles_autoconnect!r})")
|
|
return profiles_autoconnect[0]
|
|
|
|
# CSI
|
|
|
|
def _setInactive(self):
|
|
self._csi_timer = None
|
|
for client in self.host.getClients(C.PROF_KEY_ALL):
|
|
self._csi.setInactive(client)
|
|
|
|
def setInactive(self):
|
|
if self._csi is None or self._csi_timer is not None:
|
|
return
|
|
self._csi_timer = reactor.callLater(CSI_DELAY, self._setInactive)
|
|
|
|
def setActive(self):
|
|
if self._csi is None:
|
|
return
|
|
if self._csi_timer is not None:
|
|
self._csi_timer.cancel()
|
|
self._csi_timer = None
|
|
for client in self.host.getClients(C.PROF_KEY_ALL):
|
|
self._csi.setActive(client)
|
|
|
|
# Connectivity
|
|
|
|
def _handleNetworkChange(self, previous, new):
|
|
"""Notify the clients about network changes.
|
|
|
|
This way the client can disconnect/reconnect transport, or change delays
|
|
"""
|
|
if new == NET_TYPE_NONE:
|
|
for client in self.host.getClients(C.PROF_KEY_ALL):
|
|
client.networkDisabled()
|
|
elif previous == NET_TYPE_NONE:
|
|
for client in self.host.getClients(C.PROF_KEY_ALL):
|
|
client.networkEnabled()
|
|
|
|
def _checkConnectivity(self):
|
|
active_network = self.cm.getActiveNetworkInfo()
|
|
if active_network is None:
|
|
net_type = NET_TYPE_NONE
|
|
else:
|
|
net_type_android = active_network.getType()
|
|
if net_type_android == ConnectivityManager.TYPE_WIFI:
|
|
net_type = NET_TYPE_WIFI
|
|
elif net_type_android == ConnectivityManager.TYPE_MOBILE:
|
|
net_type = NET_TYPE_MOBILE
|
|
else:
|
|
net_type = NET_TYPE_OTHER
|
|
if net_type != self._net_type:
|
|
log.info("connectivity has changed")
|
|
previous = self._net_type
|
|
self._net_type = net_type
|
|
if net_type == NET_TYPE_NONE:
|
|
log.info("no network active")
|
|
elif net_type == NET_TYPE_WIFI:
|
|
log.info("WIFI activated")
|
|
elif net_type == NET_TYPE_MOBILE:
|
|
log.info("mobile data activated")
|
|
else:
|
|
log.info("network activated (type={net_type_android})"
|
|
.format(net_type_android=net_type_android))
|
|
self._handleNetworkChange(previous, net_type)
|
|
else:
|
|
log.debug("_checkConnectivity called without network change ({net_type})"
|
|
.format(net_type = net_type))
|
|
|
|
|
|
def onConnectivityChange(self):
|
|
log.debug("onConnectivityChange called")
|
|
self._checkConnectivity()
|