Build something powerful for Dolphy.

__id__ = "my_wireless_lab"
__name__ = "My Wireless Lab"
__version__ = "1.0.0"
__author__ = "Developer"
__description__ = "Wireless diagnostics"
__icon__ = "rounded:radar"
__library__ = False
__design_library__ = False
__dependencies__ = ["shared_radio_core"]
__permissions__ = ["ble_spam", "download", "files"]

__id__ = "hello_dolphy"
__name__ = "Hello Dolphy"
__version__ = "1.0.0"
__icon__ = "rounded:waving_hand"

class HelloDolphy(BasePlugin):
    def on_plugin_load(self):
        self.add_module(
            title="Hello Dolphy",
            description="My first plugin",
            icon="waving_hand",
            screen="main",
            section="PLUGINS"
        )

    def screen_main(self, ui, api, state):
        return ui.scaffold(
            title="Hello Dolphy",
            content=ui.column([
                ui.card([
                    ui.text("It works!", "headlineSmall"),
                    ui.button("Say hello", self.say_hello)
                ])
            ], padding=16, spacing=12)
        )

    def say_hello(self):
        self.toast("Hello from Python")

import json

def on_plugin_load(self):
    self.api.registerSettings("Radio toolkit", json.dumps([
        {"type": "switch", "key": "capture", "title": "Capture packets", "subtitle": "Keep a local trace", "default": True},
        {"type": "slider", "key": "power", "title": "Power", "min": 1, "max": 100, "default": 40, "steps": 98},
        {"type": "nav", "title": "Advanced", "icon": "tune", "screen": "advanced"}
    ]), 20)

def on_setting_changed(self, payload):
    key = payload["key"]
    value = payload["value"]

def on_plugin_load(self):
    self.hook_screen("ir_*", "ir_badge", "fab", 50)
    self.hook_screen("nfc_tools", "nfc_panel", "bottom", 20)
    self.hook_screen("qr_tools", "replacement", "replace", 100)

def screen_ir_badge(self, ui, api, state):
    return ui.icon_button("usb", lambda: self.navigate("hardware"))

def screen_hardware(self, ui, api, state):
    return ui.scaffold(
        title="External hardware",
        content=ui.text("Connected")
    )

def screen_nfc_panel(self, ui, api, state):
    return ui.card([
        ui.text("Plugin panel on the existing NFC screen")
    ])

def screen_replacement(self, ui, api, state):
    return ui.scaffold(
        title="My QR tools",
        content=ui.column([
            ui.text("This plugin replaced the built-in QR screen", "headlineSmall"),
            ui.button("Open original section", lambda: self.navigate_app("other"))
        ], padding=16, spacing=12, fill_max_size=True)
    )

def on_plugin_load(self):
    self.register_ble_mode("lab_beacon", "Lab Beacon", "Custom advertising payload", "radar")

def on_ble_mode_start(self, payload):
    if payload["modeId"] == "lab_beacon":
        self.start_loop(payload["delayMs"])

def on_ble_mode_delay_changed(self, payload):
    self.delay_ms = payload["delayMs"]

def on_ble_mode_stop(self, payload):
    self.stop_loop()

def on_plugin_unload(self):
    self.stop_loop()

def fetch_remote(self):
    files = [{
        "url": "https://example.org/remotes/tv.ir",
        "path": "remotes/tv.ir",
        "sizeBytes": 24576,
        "maxBytes": 100000,
        "sha256": "published SHA-256"
    }]
    self.download_assets(files, self.downloaded)

def downloaded(self, result_json):
    result = json.loads(str(result_json))
    if result.get("ok"):
        self.apply_asset("ir_remote", "remotes/tv.ir", "My TV")

def on_plugin_load(self):
    self.hook_action("bluetooth.advertising.transmit", 100)
    self.hook_action("bluetooth.advert.preset.*", 80)

def hook_bluetooth_advertising_transmit(self, payload):
    source = payload["metadata"]["source"]
    packet = payload["data"]
    if self.external_radio_ready():
        self.send_external(packet, payload.get("scanResponse"))
        return {"handled": True}
    packet["includeDeviceName"] = False
    return {"payload": payload}

def on_plugin_load(self):
    self.hook_screen("ir_*", "usb_status", "fab", 50)
    self.hook_action("infrared.transmit", 50)
    self.provide_service("infrared.transmitter", 100)

def hook_infrared_transmit(self, payload):
    payload["frequency"] = self.normalize_frequency(payload["frequency"])
    return {"payload": payload}

def service_infrared_transmitter_available(self, payload):
    return {"available": self.usb_connected()}

def service_infrared_transmitter_transmit(self, payload):
    if not self.usb_connected():
        return {"handled": False}
    ok = self.send_usb(payload["frequency"], payload["pattern"])
    return {"handled": True, "ok": ok}

__id__ = "ir_storm_hook"
__name__ = "IR Storm Hook"
__version__ = "1.0.0"
__icon__ = "rounded:settings_input_antenna"

from java import jarray, jint

class IrStormHook(BasePlugin):
    def __init__(self):
        super().__init__()
        self.current_route = ""

    def on_plugin_load(self):
        self.hook_action("infrared.transmit", 100)

    def on_navigation(self, route):
        self.current_route = str(route)

    def hook_infrared_transmit(self, payload):
        if self.current_route not in ("ir_storm", "other/ir_storm"):
            return None

        frequency = int(payload["frequency"])
        pattern = [int(value) for value in payload["pattern"]]
        ok = self.send_to_external_ir(frequency, pattern)
        return {
            "handled": True,
            "result": ok
        }

    def send_to_external_ir(self, frequency, pattern):
        android = self.api.getAndroid()
        java_pattern = jarray(jint)(pattern)
        return android.irTransmit(frequency, java_pattern)

__id__ = "shared_radio_core"
__name__ = "Shared Radio Core"
__version__ = "1.0.0"
__library__ = True

DEX_SHA256 = "48c3cb64ad3c0e82b7352549f7568e4e42119fc6b066a050054474e6fffca28c"
DEX_BASE64 = "ZGV4CjAzNQ..."

class SharedRadioCore(BasePlugin):
    def on_plugin_load(self):
        loader = self.load_dex_base64("radio_core", DEX_BASE64, DEX_SHA256)
        bridge_class = loader.loadClass("dev.dolphy.radio.RadioBridge")
        constructor = bridge_class.getDeclaredConstructor()
        constructor.setAccessible(True)
        bridge = constructor.newInstance()
        self.export_java_class("radio.bridge.class", bridge_class)
        self.export_java_object("radio.bridge", bridge)

    def on_plugin_unload(self):
        bridge = self.import_java_object("radio.bridge")
        if bridge is not None:
            bridge.close()

__id__ = "radio_consumer"
__name__ = "Radio Consumer"
__dependencies__ = ["shared_radio_core"]

class RadioConsumer(BasePlugin):
    def on_plugin_load(self):
        self.bridge = self.import_java_object("radio.bridge")
        bridge_class = self.import_java_class("radio.bridge.class")
        if self.bridge is None or bridge_class is None:
            raise RuntimeError("Shared Radio Core did not export its API")
        self.add_module("Radio Console", "Uses the shared native bridge", "memory")

    def scan(self):
        result = self.bridge.scan()
        self.toast(str(result))

import json

class HardwarePlugin(BasePlugin):
    def on_plugin_load(self):
        self.devices = []
        self.api.bleStartScan("nearby", self.on_ble_batch, 350, 128)

    def on_ble_batch(self, payload_json):
        self.devices = json.loads(str(payload_json))
        self.refresh()

    def connect_gatt(self, address):
        android = self.api.getAndroid()
        return android.gattConnect(address, self.on_gatt_event)

    def on_gatt_event(self, payload_json):
        event = json.loads(str(payload_json))

    def on_plugin_unload(self):
        self.api.bleStopScan("nearby")
        self.api.getAndroid().release()