Eclipse Kura #

┌─────────────────────────────────────────────────────────┐
│                    Kura架构                              │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌─────────────────────────────────────────────────┐   │
│  │              应用层 (Applications)               │   │
│  └─────────────────────────────────────────────────┘   │
│                         │                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │              服务层 (Services)                   │   │
│  │  ┌─────────┬─────────┬─────────┬─────────┐      │   │
│  │  │ 数据服务 │ 云服务  │ 网络服务 │ 配置服务 │      │   │
│  │  └─────────┴─────────┴─────────┴─────────┘      │   │
│  └─────────────────────────────────────────────────┘   │
│                         │                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │              抽象层 (Abstractions)               │   │
│  │  ┌─────────┬─────────┬─────────┬─────────┐      │   │
│  │  │ GPIO    │ 串口    │ I2C     │ SPI     │      │   │
│  │  └─────────┴─────────┴─────────┴─────────┘      │   │
│  └─────────────────────────────────────────────────┘   │
│                         │                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │              OSGi容器 (Equinox/Felix)           │   │
│  └─────────────────────────────────────────────────┘   │
│                         │                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │              操作系统 (Linux)                    │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
└─────────────────────────────────────────────────────────┘

package com.example.kura;

import org.eclipse.kura.configuration.ConfigurableComponent;
import org.osgi.service.component.ComponentContext;
import java.util.Map;

public class SensorComponent implements ConfigurableComponent {

    private static final String PROP_INTERVAL = "interval";
    private static final String PROP_ENABLED = "enabled";
    
    private int interval = 5000;
    private boolean enabled = true;
    
    private Thread sensorThread;
    private volatile boolean running = false;
    
    protected void activate(ComponentContext context, Map<String, Object> properties) {
        updated(properties);
        
        System.out.println("传感器组件激活");
        startSensor();
    }
    
    protected void deactivate(ComponentContext context) {
        System.out.println("传感器组件停用");
        stopSensor();
    }
    
    protected void updated(Map<String, Object> properties) {
        if (properties != null) {
            if (properties.containsKey(PROP_INTERVAL)) {
                interval = (Integer) properties.get(PROP_INTERVAL);
            }
            if (properties.containsKey(PROP_ENABLED)) {
                enabled = (Boolean) properties.get(PROP_ENABLED);
            }
        }
        
        System.out.println("配置更新: interval=" + interval + ", enabled=" + enabled);
    }
    
    private void startSensor() {
        if (!enabled) return;
        
        running = true;
        sensorThread = new Thread(() -> {
            while (running) {
                try {
                    readSensor();
                    Thread.sleep(interval);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        sensorThread.start();
    }
    
    private void stopSensor() {
        running = false;
        if (sensorThread != null) {
            sensorThread.interrupt();
        }
    }
    
    private void readSensor() {
        double value = 20 + Math.random() * 10;
        System.out.println("传感器读数: " + value);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<scr:component 
    xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0"
    name="com.example.kura.SensorComponent"
    activate="activate"
    deactivate="deactivate"
    modified="updated"
    configuration-policy="require">
    
    <implementation class="com.example.kura.SensorComponent"/>
    
    <property name="service.pid" value="com.example.kura.SensorComponent"/>
    <property name="interval" type="Integer" value="5000"/>
    <property name="enabled" type="Boolean" value="true"/>
    
    <service>
        <provide interface="org.eclipse.kura.configuration.ConfigurableComponent"/>
    </service>
</scr:component>

package com.example.kura;

import org.eclipse.kura.KuraException;
import org.eclipse.kura.data.DataService;
import org.osgi.service.component.ComponentContext;

public class DataPublisher {

    private DataService dataService;
    
    protected void activate(ComponentContext context) {
        System.out.println("数据发布者激活");
    }
    
    protected void deactivate(ComponentContext context) {
        System.out.println("数据发布者停用");
    }
    
    public void setDataService(DataService dataService) {
        this.dataService = dataService;
    }
    
    public void unsetDataService(DataService dataService) {
        this.dataService = null;
    }
    
    public void publish(String topic, byte[] payload) {
        if (dataService != null && dataService.isConnected()) {
            try {
                dataService.publish(topic, payload, 1, false);
                System.out.println("数据已发布到: " + topic);
            } catch (KuraException e) {
                e.printStackTrace();
            }
        }
    }
    
    public void publishSensorData(String sensorName, double value) {
        String topic = "sensor/" + sensorName;
        String payload = String.format("{\"value\":%.2f,\"timestamp\":%d}",
            value, System.currentTimeMillis());
        publish(topic, payload.getBytes());
    }
}

package com.example.kura;

import org.eclipse.kura.cloud.CloudClient;
import org.eclipse.kura.cloud.CloudService;
import org.eclipse.kura.KuraException;
import org.osgi.service.component.ComponentContext;

public class CloudConnector {

    private CloudService cloudService;
    private CloudClient cloudClient;
    
    protected void activate(ComponentContext context) {
        try {
            if (cloudService != null) {
                cloudClient = cloudService.newCloudClient("app-id");
                System.out.println("云客户端创建成功");
            }
        } catch (KuraException e) {
            e.printStackTrace();
        }
    }
    
    protected void deactivate(ComponentContext context) {
        if (cloudClient != null) {
            cloudClient.release();
        }
    }
    
    public void setCloudService(CloudService cloudService) {
        this.cloudService = cloudService;
    }
    
    public void unsetCloudService(CloudService cloudService) {
        this.cloudService = null;
    }
    
    public void publishToCloud(String topic, byte[] payload) {
        if (cloudClient != null) {
            try {
                cloudClient.publish(topic, payload, 1, false, 5);
                System.out.println("数据已发布到云: " + topic);
            } catch (KuraException e) {
                e.printStackTrace();
            }
        }
    }
}