openCom-Companion/sbapp/services/sidebandservice.py

337 lines
14 KiB
Python
Raw Normal View History

2022-11-03 22:55:35 +01:00
__debug_build__ = False
2022-10-11 14:20:01 +02:00
import time
2022-09-20 17:28:39 +02:00
import RNS
from os import environ
from kivy.logger import Logger, LOG_LEVELS
2022-10-11 14:20:01 +02:00
2022-10-13 21:22:16 +02:00
if __debug_build__:
2022-10-11 14:20:01 +02:00
Logger.setLevel(LOG_LEVELS["debug"])
else:
Logger.setLevel(LOG_LEVELS["error"])
if RNS.vendor.platformutils.get_platform() == "android":
from jnius import autoclass, cast
from android import python_act
android_api_version = autoclass('android.os.Build$VERSION').SDK_INT
Context = autoclass('android.content.Context')
Intent = autoclass('android.content.Intent')
BitmapFactory = autoclass('android.graphics.BitmapFactory')
Icon = autoclass("android.graphics.drawable.Icon")
PendingIntent = autoclass('android.app.PendingIntent')
AndroidString = autoclass('java.lang.String')
NotificationManager = autoclass('android.app.NotificationManager')
Context = autoclass('android.content.Context')
if android_api_version >= 26:
NotificationBuilder = autoclass('android.app.Notification$Builder')
NotificationChannel = autoclass('android.app.NotificationChannel')
2022-10-11 14:20:01 +02:00
from usb4a import usb
from usbserial4a import serial4a
from sideband.core import SidebandCore
2022-09-28 13:12:14 +02:00
else:
from sbapp.sideband.core import SidebandCore
2022-09-28 13:12:14 +02:00
class SidebandService():
def android_notification(self, title="", content="", ticker="", group=None, context_id=None):
if android_api_version < 26:
return
else:
package_name = "io.unsigned.sideband"
if not self.notification_service:
self.notification_service = cast(NotificationManager, self.app_context.getSystemService(
Context.NOTIFICATION_SERVICE
))
channel_id = package_name
group_id = ""
if group != None:
channel_id += "."+str(group)
group_id += str(group)
if context_id != None:
channel_id += "."+str(context_id)
group_id += "."+str(context_id)
if not title or title == "":
channel_name = "Sideband"
else:
channel_name = title
self.notification_channel = NotificationChannel(channel_id, channel_name, NotificationManager.IMPORTANCE_DEFAULT)
self.notification_channel.enableVibration(True)
self.notification_channel.setShowBadge(True)
self.notification_service.createNotificationChannel(self.notification_channel)
notification = NotificationBuilder(self.app_context, channel_id)
notification.setContentTitle(title)
notification.setContentText(AndroidString(content))
# if group != None:
# notification.setGroup(group_id)
if not self.notification_small_icon:
path = self.sideband.notification_icon
bitmap = BitmapFactory.decodeFile(path)
self.notification_small_icon = Icon.createWithBitmap(bitmap)
notification.setSmallIcon(self.notification_small_icon)
# large_icon_path = self.sideband.icon
# bitmap_icon = BitmapFactory.decodeFile(large_icon_path)
# notification.setLargeIcon(bitmap_icon)
if not self.notification_intent:
notification_intent = Intent(self.app_context, python_act)
notification_intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
notification_intent.setAction(Intent.ACTION_MAIN)
notification_intent.addCategory(Intent.CATEGORY_LAUNCHER)
self.notification_intent = PendingIntent.getActivity(self.app_context, 0, notification_intent, 0)
notification.setContentIntent(self.notification_intent)
notification.setAutoCancel(True)
built_notification = notification.build()
self.notification_service.notify(0, built_notification)
def __init__(self):
2022-09-20 17:28:39 +02:00
self.argument = environ.get('PYTHON_SERVICE_ARGUMENT', '')
self.app_dir = self.argument
2022-09-20 17:28:39 +02:00
self.multicast_lock = None
self.wake_lock = None
self.should_run = False
2022-09-20 17:28:39 +02:00
self.android_service = None
self.app_context = None
self.wifi_manager = None
self.power_manager = None
2022-10-11 14:20:01 +02:00
self.usb_devices = []
self.notification_service = None
self.notification_channel = None
self.notification_intent = None
self.notification_small_icon = None
2022-10-11 14:20:01 +02:00
if RNS.vendor.platformutils.is_android():
self.android_service = autoclass('org.kivy.android.PythonService').mService
self.app_context = self.android_service.getApplication().getApplicationContext()
self.wifi_manager = self.app_context.getSystemService(Context.WIFI_SERVICE)
self.power_manager = self.app_context.getSystemService(Context.POWER_SERVICE)
# The returned instance /\ is an android.net.wifi.WifiManager
2022-10-11 14:20:01 +02:00
self.discover_usb_devices()
2022-09-20 17:28:39 +02:00
2022-10-11 14:20:01 +02:00
self.sideband = SidebandCore(self, is_service=True, android_app_dir=self.app_dir, verbose=__debug_build__)
self.sideband.service_context = self.android_service
self.sideband.owner_service = self
self.sideband.start()
2022-10-02 20:43:56 +02:00
self.update_connectivity_type()
2022-10-11 14:20:01 +02:00
if RNS.vendor.platformutils.is_android():
RNS.log("Discovered USB devices: "+str(self.usb_devices), RNS.LOG_DEBUG)
def discover_usb_devices(self):
self.usb_devices = []
RNS.log("Discovering attached USB devices...", RNS.LOG_DEBUG)
try:
devices = usb.get_usb_device_list()
for device in devices:
device_entry = {
"port": device.getDeviceName(),
"vid": device.getVendorId(),
"pid": device.getProductId(),
"manufacturer": device.getManufacturerName(),
"productname": device.getProductName(),
}
self.usb_devices.append(device_entry)
except Exception as e:
RNS.log("Could not list USB devices. The contained exception was: "+str(e), RNS.LOG_ERROR)
def start(self):
self.should_run = True
2022-09-20 17:28:39 +02:00
self.take_locks()
self.run()
def stop(self):
self.should_run = False
2022-09-20 17:28:39 +02:00
def take_locks(self):
if RNS.vendor.platformutils.get_platform() == "android":
if self.multicast_lock == None:
self.multicast_lock = self.wifi_manager.createMulticastLock("sideband_service")
2022-09-20 17:28:39 +02:00
if not self.multicast_lock.isHeld():
RNS.log("Taking multicast lock")
self.multicast_lock.acquire()
2022-09-20 17:28:39 +02:00
if self.wake_lock == None:
self.wake_lock = self.power_manager.newWakeLock(self.power_manager.PARTIAL_WAKE_LOCK, "sideband_service")
if not self.wake_lock.isHeld():
RNS.log("Taking wake lock")
self.wake_lock.acquire()
def release_locks(self):
if RNS.vendor.platformutils.get_platform() == "android":
if not self.multicast_lock == None and self.multicast_lock.isHeld():
2022-10-02 10:58:00 +02:00
RNS.log("Releasing multicast lock")
self.multicast_lock.release()
2022-09-20 17:28:39 +02:00
if not self.wake_lock == None and self.wake_lock.isHeld():
2022-10-02 10:58:00 +02:00
RNS.log("Releasing wake lock")
self.wake_lock.release()
2022-10-02 20:43:56 +02:00
def update_connectivity_type(self):
if self.sideband.reticulum.is_connected_to_shared_instance:
is_controlling = False
else:
is_controlling = True
self.sideband.setpersistent("service.is_controlling_connectivity", is_controlling)
def get_connectivity_status(self):
if self.sideband.reticulum.is_connected_to_shared_instance:
return "[size=22dp][b]Connectivity Status[/b][/size]\n\nSideband is connected via a shared Reticulum instance running on this system. Use the rnstatus utility to obtain full connectivity info."
else:
ws = "Disabled"
ts = "Disabled"
i2s = "Disabled"
2022-10-13 22:40:48 +02:00
stat = "[size=22dp][b]Connectivity Status[/b][/size]\n\n"
2022-10-02 20:43:56 +02:00
if self.sideband.interface_local != None:
netdevs = self.sideband.interface_local.adopted_interfaces
if len(netdevs) > 0:
ds = "Using "
for netdev in netdevs:
ds += "[i]"+str(netdev)+"[/i], "
ds = ds[:-2]
else:
ds = "No usable network devices"
2022-10-02 20:43:56 +02:00
np = len(self.sideband.interface_local.peers)
if np == 1:
ws = "1 reachable peer"
else:
ws = str(np)+" reachable peers"
stat += "[b]Local[/b]\n{ds}\n{ws}\n\n".format(ds=ds, ws=ws)
2022-10-13 22:40:48 +02:00
if self.sideband.interface_rnode != None:
if self.sideband.interface_rnode.online:
rs = "On-air at "+str(self.sideband.interface_rnode.bitrate_kbps)+" Kbps"
else:
rs = "Interface Down"
stat += "[b]RNode[/b]\n{rs}\n\n".format(rs=rs)
if self.sideband.interface_modem != None:
if self.sideband.interface_modem.online:
rm = "Connected"
else:
rm = "Interface Down"
stat += "[b]Radio Modem[/b]\n{rm}\n\n".format(rm=rm)
if self.sideband.interface_serial != None:
if self.sideband.interface_serial.online:
rs = "Running at "+RNS.prettysize(self.sideband.interface_serial.bitrate/8, suffix="b")+"ps"
else:
rs = "Interface Down"
stat += "[b]Serial Port[/b]\n{rs}\n\n".format(rs=rs)
2022-10-02 20:43:56 +02:00
if self.sideband.interface_tcp != None:
if self.sideband.interface_tcp.online:
ts = "Connected to "+str(self.sideband.interface_tcp.target_ip)+":"+str(self.sideband.interface_tcp.target_port)
else:
ts = "Interface Down"
2022-10-13 22:40:48 +02:00
stat += "[b]TCP[/b]\n{ts}\n\n".format(ts=ts)
2022-10-02 20:43:56 +02:00
if self.sideband.interface_i2p != None:
i2s = "Unknown"
if hasattr(self.sideband.interface_i2p, "i2p_tunnel_state") and self.sideband.interface_i2p.i2p_tunnel_state != None:
if self.sideband.interface_i2p.i2p_tunnel_state == RNS.Interfaces.I2PInterface.I2PInterfacePeer.TUNNEL_STATE_INIT:
i2s = "Tunnel Connecting"
elif self.sideband.interface_i2p.i2p_tunnel_state == RNS.Interfaces.I2PInterface.I2PInterfacePeer.TUNNEL_STATE_ACTIVE:
i2s = "Tunnel Active"
elif self.sideband.interface_i2p.i2p_tunnel_state == RNS.Interfaces.I2PInterface.I2PInterfacePeer.TUNNEL_STATE_STALE:
i2s = "Tunnel Unresponsive"
2022-10-02 20:43:56 +02:00
else:
if self.sideband.interface_i2p.online:
i2s = "Connected"
else:
i2s = "Connecting to I2P"
2022-10-02 20:43:56 +02:00
stat += "[b]I2P[/b]\n{i2s}\n\n".format(i2s=i2s)
total_rxb = 0
total_txb = 0
if self.sideband.interface_local != None:
total_rxb += self.sideband.interface_local.rxb
total_txb += self.sideband.interface_local.txb
if self.sideband.interface_rnode != None:
total_rxb += self.sideband.interface_rnode.rxb
total_txb += self.sideband.interface_rnode.txb
if self.sideband.interface_modem != None:
total_rxb += self.sideband.interface_modem.rxb
total_txb += self.sideband.interface_modem.txb
if self.sideband.interface_serial != None:
total_rxb += self.sideband.interface_serial.rxb
total_txb += self.sideband.interface_serial.txb
if self.sideband.interface_tcp != None:
total_rxb += self.sideband.interface_tcp.rxb
total_txb += self.sideband.interface_tcp.txb
if self.sideband.interface_i2p != None:
total_rxb += self.sideband.interface_i2p.rxb
total_txb += self.sideband.interface_i2p.txb
if RNS.Reticulum.transport_enabled():
stat += "[b]Transport Instance[/b]\nRouting Traffic\n\n"
stat += "[b]Traffic[/b]\nIn: {inb}\nOut: {outb}\n\n".format(inb=RNS.prettysize(total_rxb), outb=RNS.prettysize(total_txb))
if stat.endswith("\n\n"):
stat = stat[:-2]
2022-10-13 22:40:48 +02:00
return stat
2022-10-02 20:43:56 +02:00
def run(self):
while self.should_run:
sleep_time = 1
self.sideband.setstate("service.heartbeat", time.time())
2022-10-02 20:43:56 +02:00
self.sideband.setstate("service.connectivity_status", self.get_connectivity_status())
if self.sideband.getstate("wants.service_stop"):
self.should_run = False
sleep_time = 0
2022-10-02 12:15:37 +02:00
if self.sideband.getstate("wants.clear_notifications"):
self.sideband.setstate("wants.clear_notifications", False)
if self.notification_service != None:
self.notification_service.cancelAll()
2022-10-02 12:45:06 +02:00
if self.sideband.getstate("wants.settings_reload"):
self.sideband.setstate("wants.settings_reload", False)
self.sideband.reload_configuration()
time.sleep(sleep_time)
self.sideband.cleanup()
self.release_locks()
2022-10-15 23:16:44 +02:00
SidebandService().start()