Editing Openai/691a15e5-9180-8001-a5a0-9b83ec27e6fe (section)

==== Se invece vuoi un vero binding openHAB, la strada è: ====

===== - Binding ID: org.openhab.binding.econnect =====
* Bridge Thing: account e-Connect / Metronet Config: - username - password - system (Elmo / IESS) - domain (come nell’integrazione HA: default, vendor, ecc.) GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref> - eventuali parametri (polling interval, timeout, ecc.)
* Child Things: - alarm_panel (stato generale, comandi arm/disarm). - area / sector (stato di singole aree/settori). - opzionale: input / output per ingressi/uscite.
* Channels (esempio): - alarm_panel: - arm_state (String/enum: DISARMED, ARMED_AWAY, ARMED_HOME, ARMED_NIGHT…) - command (String o Rollershutter-style, su cui intercetti i comandi in handleCommand) - last_event (String) - sector: - open (Contact) - alarm (Switch) - ecc.

===== Nel repo di HA trovi tutta la logica di accesso al cloud e-Connect in Python: GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref> =====
* custom_components/econnect_metronet/ lì ci sono: - il client che fa login (POST iniziale), gestisce i cookie/sessione, recupera lo stato. - le chiamate per armare/disarmare e leggere i settori.

Passi pratici:
# Studiare il client Python - Chiamate HTTP (endpoint, metodo, payload, headers). - Meccanismo di login (form, JSON, token). - Formato del JSON restituito con lo stato (zone, inputs, outputs, ecc.).
# Riscrivere il client in Java dentro il binding: - usare Apache HttpClient o la HTTP API di openHAB (a seconda della versione) per le chiamate. - mappare le risposte JSON con Jackson / GSON.
# Schedulare il polling: - Nel BridgeHandler.initialize() avviare uno scheduler (scheduler.scheduleWithFixedDelay) che ogni X secondi: - aggiorna lo stato dal cloud - chiama updateState(...) sui Channels delle Things figlie.
# Gestire i comandi: - Nel ThingHandler.handleCommand(...) dell’alarm panel, tradurre ON/OFF o comandi stringa in chiamate HTTP (arm/disarm). - Inserire la necessaria sicurezza: p.e. un String channel per il codice PIN, o usare un Item separato.

===== : =====

<code>EconnectBindingConstants.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect;

public class EconnectBindingConstants {

    public static final String BINDING_ID = "econnect";

    // Thing types
    public static final String THING_TYPE_BRIDGE = "bridge";
    public static final String THING_TYPE_ALARM_PANEL = "alarm_panel";

    // Channels - alarm panel
    public static final String CHANNEL_ALARM_STATE = "alarm_state";
    public static final String CHANNEL_LAST_EVENT = "last_event";
    public static final String CHANNEL_COMMAND = "command";
}

</syntaxhighlight>

<code>EconnectHandlerFactory.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import static org.openhab.binding.econnect.EconnectBindingConstants.*;

import java.util.Set;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.binding.BaseThingHandlerFactory;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.BridgeHandler;
import org.osgi.service.component.annotations.Component;

@NonNullByDefault
@Component(service = org.openhab.core.thing.binding.ThingHandlerFactory.class)
public class EconnectHandlerFactory extends BaseThingHandlerFactory {

    public static final ThingTypeUID BRIDGE_TYPE_UID = new ThingTypeUID(BINDING_ID, THING_TYPE_BRIDGE);
    public static final ThingTypeUID ALARM_PANEL_TYPE_UID = new ThingTypeUID(BINDING_ID, THING_TYPE_ALARM_PANEL);

    @Override
    public boolean supportsThingType(ThingTypeUID thingTypeUID) {
        return BRIDGE_TYPE_UID.equals(thingTypeUID) || ALARM_PANEL_TYPE_UID.equals(thingTypeUID);
    }

    @Override
    protected @Nullable ThingHandler createHandler(Thing thing) {
        ThingTypeUID thingTypeUID = thing.getThingTypeUID();

        if (BRIDGE_TYPE_UID.equals(thingTypeUID)) {
            return new EconnectBridgeHandler(thing);
        } else if (ALARM_PANEL_TYPE_UID.equals(thingTypeUID)) {
            return new EconnectAlarmPanelHandler(thing);
        }
        return null;
    }
}

</syntaxhighlight>

<code>EconnectBridgeHandler.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingStatusDetail;
import org.openhab.core.thing.binding.BaseBridgeHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@NonNullByDefault
public class EconnectBridgeHandler extends BaseBridgeHandler {

    private final Logger logger = LoggerFactory.getLogger(EconnectBridgeHandler.class);

    private ScheduledFuture<?> refreshJob;

    // Qui andrebbe il tuo client Java per e-Connect
    private EconnectClient client;

    public EconnectBridgeHandler(Bridge bridge) {
        super(bridge);
    }

    @Override
    public void initialize() {
        logger.debug("Initializing Econnect bridge");

        // TODO: leggere i parametri di config (username, password, system, domain, pollInterval)
        // Eseguire login sul cloud
        try {
            // client = new EconnectClient(config...);
            // client.login();

            updateStatus(ThingStatus.ONLINE);

            int pollIntervalSeconds = 10; // o da config
            refreshJob = scheduler.scheduleWithFixedDelay(this::refresh, 0, pollIntervalSeconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, e.getMessage());
        }
    }

    private void refresh() {
        try {
            // Legge stato dal cloud
            // EconnectState state = client.getState();

            // Propagare lo stato alle Things figlie
            getThing().getThings().forEach(child -> {
                if (child.getHandler() instanceof EconnectAlarmPanelHandler panelHandler) {
                    // panelHandler.updateFromState(state);
                }
            });
        } catch (Exception e) {
            logger.warn("Error refreshing Econnect state", e);
        }
    }

    @Override
    public void dispose() {
        if (refreshJob != null && !refreshJob.isCancelled()) {
            refreshJob.cancel(true);
        }
        // client.logout() se necessario
        super.dispose();
    }

    public EconnectClient getClient() {
        return client;
    }
}

</syntaxhighlight>

<code>EconnectAlarmPanelHandler.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import static org.openhab.binding.econnect.EconnectBindingConstants.*;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.library.types.StringType;
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.thing.ChannelUID;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.binding.BaseThingHandler;
import org.openhab.core.types.Command;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@NonNullByDefault
public class EconnectAlarmPanelHandler extends BaseThingHandler {

    private final Logger logger = LoggerFactory.getLogger(EconnectAlarmPanelHandler.class);

    public EconnectAlarmPanelHandler(Thing thing) {
        super(thing);
    }

    @Override
    public void initialize() {
        updateStatus(org.openhab.core.thing.ThingStatus.UNKNOWN);
    }

    @Override
    public void handleCommand(ChannelUID channelUID, Command command) {
        if (CHANNEL_COMMAND.equals(channelUID.getId())) {
            logger.debug("Received command {} for alarm panel", command);

            if (command instanceof OnOffType) {
                // esempio: ON = arm_away, OFF = disarm
                String action = command == OnOffType.ON ? "arm_away" : "disarm";
                sendAlarmCommand(action);
            } else if (command instanceof StringType stringCmd) {
                sendAlarmCommand(stringCmd.toString()); // "arm_home", "arm_night", etc.
            }
        }
    }

    private void sendAlarmCommand(String action) {
        try {
            EconnectBridgeHandler bridge = (EconnectBridgeHandler) getBridge().getHandler();
            EconnectClient client = bridge.getClient();

            switch (action) {
                case "arm_away":
                    client.armAllAreas();
                    break;
                case "disarm":
                    client.disarmAllAreas();
                    break;
                case "arm_home":
                    client.armHome();
                    break;
                case "arm_night":
                    client.armNight();
                    break;
                default:
                    logger.warn("Unknown alarm action: {}", action);
            }
        } catch (Exception e) {
            logger.warn("Failed to send alarm command {}", action, e);
        }
    }

    // Chiamata dal Bridge quando ha un nuovo stato
    public void updateFromState(EconnectState state) {
        // TODO: mappare lo stato generale dell’allarme
        // updateState(new ChannelUID(getThing().getUID(), CHANNEL_ALARM_STATE),
        //            new StringType(state.getAlarmStatus()));
    }
}

</syntaxhighlight>

===== - Implementare <code>EconnectClient</code> (login, polling, comandi) copiando la logica del client Python. =====
* Definire i file XML: - econnect.things (thing-types, channels, ecc.). - econnect.config (parametri di configurazione del bridge).
* Integrare il binding nel repository openHAB (o come add-on esterno in addons/).
* Fare un po’ di test con il tuo impianto reale.