Network-side rewrite

build.gradle

@@ -47,7 +47,7 @@ publishing {
             }
             pom {
                 name = rootProject.name
-                description = "An SDK to easily communicate with your Gree appliances. Separated from GreeControlAndroid."
+                description = "An SDK to easily communicate with your Gree appliances. Originally separated from GreeControlAndroid, and then got a full rewrite."
                 url = "https://docs.czsoft.eu/greesdk?v=" + rootProject.version
                 developers {
                     developer {

gradle.properties

@@ -1,5 +1,5 @@
 artifactId = greesdk
 name = GreeSDK
-version = 0.1.0
+version = 1.1.3
 
 mavenUrl = https://maven.czsoft.eu/

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Fri Jul 28 12:25:52 CEST 2023
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

src/main/java/eu/czsoft/greesdk/Crypto.java

@@ -1,35 +1,35 @@
 package eu.czsoft.greesdk;
 
-import android.util.Base64;
-import android.util.Log;
+import lombok.extern.java.Log;
 
 import javax.crypto.Cipher;
 import javax.crypto.spec.SecretKeySpec;
+import java.util.Base64;
 
+@Log
 public class Crypto {
-    private static final String LOG_TAG = "Crypto";
-    public static String GENERIC_KEY = "a3K8Bx%2r8Y7#xDh";
+    protected static String GENERIC_KEY = "a3K8Bx%2r8Y7#xDh";
 
-    public static String encrypt(String plainText, String key) {
+    protected static String encrypt(String plainText, String key) {
         try {
             Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
             SecretKeySpec keySpec = new SecretKeySpec(key.getBytes("ASCII"), "AES");
             c.init(Cipher.ENCRYPT_MODE, keySpec);
 
             byte[] encrypted = c.doFinal(plainText.getBytes("UTF-8"));
-            String encoded = new String(Base64.encode(encrypted, Base64.DEFAULT));
+            String encoded = new String(Base64.getEncoder().encode(encrypted));
 
             return encoded;
         } catch (Exception e) {
-            Log.e(LOG_TAG, "Pack encryption failed. Error: " + e.getMessage());
+            LOGGER.severe("Pack encryption failed. Error: " + e.getMessage());
         }
 
         return "";
     }
 
-    public static String decrypt(String encrypted, String key) {
+    protected static String decrypt(String encrypted, String key) {
         try {
-            byte[] decoded = Base64.decode(encrypted, Base64.DEFAULT);
+            byte[] decoded = Base64.getDecoder().decode(encrypted);
 
             Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding");
             SecretKeySpec keySpec = new SecretKeySpec(key.getBytes("ASCII"), "AES");
@@ -38,7 +38,7 @@ public static String decrypt(String encrypted, String key) {
             byte[] decrypted = c.doFinal(decoded);
             return new String(decrypted);
         } catch (Exception e) {
-            Log.e(LOG_TAG, "Pack decryption failed. Error: " + e.getMessage());
+            LOGGER.severe("Pack decryption failed. Error: " + e.getMessage());
         }
 
         return "";

src/main/java/eu/czsoft/greesdk/DeviceManager.java

@@ -0,0 +1,277 @@
+package eu.czsoft.greesdk;
+
+import eu.czsoft.greesdk.appliances.ApplianceImpl;
+import eu.czsoft.greesdk.appliances.Appliance;
+import eu.czsoft.greesdk.appliances.Parameter;
+import eu.czsoft.greesdk.net.DeviceKeyChain;
+import eu.czsoft.greesdk.net.communication.AsyncCommunicationFinishedListener;
+import eu.czsoft.greesdk.net.communication.AsyncCommunicator;
+import eu.czsoft.greesdk.net.packets.Packet;
+import eu.czsoft.greesdk.net.packets.packs.clientbound.BindResponsePack;
+import eu.czsoft.greesdk.net.packets.packs.clientbound.DeviceResponsePack;
+import eu.czsoft.greesdk.net.packets.packs.clientbound.ResultPack;
+import eu.czsoft.greesdk.net.packets.packs.serverbound.BindRequestPack;
+import eu.czsoft.greesdk.net.packets.packs.serverbound.ChangeOptionRequestPack;
+import eu.czsoft.greesdk.net.packets.packs.serverbound.CommandRequestPack;
+import eu.czsoft.greesdk.net.packets.packs.serverbound.StatusResponsePack;
+import eu.czsoft.greesdk.net.packets.serverbound.ApplicationPacket;
+import eu.czsoft.greesdk.net.packets.serverbound.ScanAppliancesPacket;
+import eu.czsoft.greesdk.net.packets.serverbound.WiFiSettingsPacket;
+import lombok.extern.java.Log;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@Log
+public class DeviceManager {
+    private final int DATAGRAM_PORT = 7000;
+
+    private static DeviceManager instance = null;
+
+    private final HashMap<String, ApplianceImpl> devices = new HashMap<>();
+    private final DeviceKeyChain keyChain = new DeviceKeyChain();
+    private final ArrayList<DeviceManagerEventListener> eventListeners = new ArrayList<>();
+
+    public static DeviceManager getInstance() {
+        if (instance == null)
+            instance = new DeviceManager();
+
+        return instance;
+    }
+
+    protected DeviceManager() {
+        LOGGER.info("Created");
+    }
+
+    public Appliance[] getDevices() {
+        return devices.values().toArray(new Appliance[0]);
+    }
+
+    public Appliance getDevice(String deviceId) {
+        if (devices.containsKey(deviceId))
+            return devices.get(deviceId);
+
+        return null;
+    }
+
+    public void registerEventListener(DeviceManagerEventListener listener) {
+        if (!eventListeners.contains(listener))
+            eventListeners.add(listener);
+    }
+
+    public void unregisterEventListener(DeviceManagerEventListener listener) {
+        eventListeners.remove(listener);
+    }
+
+    public void setParameter(ApplianceImpl device, String name, int value) {
+        HashMap<String, Integer> p = new HashMap<>();
+        p.put(name, value);
+
+        setParameters(device, p);
+    }
+
+    public void setParameters(ApplianceImpl device, Map<String, Integer> parameters) {
+        LOGGER.fine(String.format("Setting parameters of %s: %s", device.getId(), parameters));
+
+        ApplicationPacket packet = new ApplicationPacket();
+        packet.targetClientId = device.getId();
+        packet.i = 0;
+
+        CommandRequestPack pack = new CommandRequestPack();
+        pack.options = parameters.keySet().toArray(new String[0]);
+        pack.values = parameters.values().toArray(new Integer[0]);
+        pack.mac = packet.targetClientId;
+
+        packet.pack = pack;
+
+        final AsyncCommunicator comm = new AsyncCommunicator(keyChain);
+        comm.setCommunicationFinishedListener(new AsyncCommunicationFinishedListener() {
+            @Override
+            public void onFinished() {
+                try {
+                    final Packet[] responses = comm.get();
+
+                    for (Packet response : responses) {
+                        if (devices.containsKey(response.clientId)) {
+                            devices.get(response.clientId).updateWithResultPack((ResultPack) response.pack);
+                        }
+                    }
+
+                    sendEvent(DeviceManagerEvent.DEVICE_STATUS_UPDATED);
+                } catch (Exception e) {
+                    LOGGER.severe("Failed to get response of command. Error: " + e.getMessage());
+                }
+            }
+        });
+        comm.execute(new Packet[] { packet });
+    }
+
+    public void setWiFi(String ssid, String password){
+
+        WiFiSettingsPacket packet = new WiFiSettingsPacket();
+        packet.password = password;
+        packet.ssid = ssid;
+
+        final AsyncCommunicator comm = new AsyncCommunicator(keyChain);
+        comm.setCommunicationFinishedListener(new AsyncCommunicationFinishedListener() {
+            @Override
+            public void onFinished() {
+                try {
+                    final Packet[] responses = comm.get();
+
+                    for (Packet response : responses) {
+                        if (devices.containsKey(response.clientId)) {
+                            devices.get(response.clientId).updateWithResultPack((ResultPack) response.pack);
+                        }
+                    }
+
+                    sendEvent(DeviceManagerEvent.DEVICE_STATUS_UPDATED);
+                } catch (Exception e) {
+                    LOGGER.severe("Failed to get response of command. Error: " + e.getMessage());
+                }
+            }
+        });
+        comm.execute(new Packet[] { packet });
+    }
+
+    public void discoverDevices() {
+        LOGGER.info("Device discovery running...");
+
+        final AsyncCommunicator comm = new AsyncCommunicator();
+        comm.setCommunicationFinishedListener(new AsyncCommunicationFinishedListener() {
+            @Override
+            public void onFinished() {
+                try {
+                    Packet[] responses = comm.get();
+                    LOGGER.info(String.format("Got %d response(s)", responses.length));
+
+                    bindDevices(responses);
+                } catch (Exception e) {
+                    LOGGER.fine("Device discovery failed with exception\n" + e);
+                }
+            }
+        });
+
+        ScanAppliancesPacket sp = new ScanAppliancesPacket();
+
+        comm.execute(new ScanAppliancesPacket[]{ sp });
+    }
+
+    public void updateDevices() {
+        if (devices.isEmpty()) {
+            LOGGER.info("No devices to update");
+            return;
+        }
+
+        LOGGER.info(String.format("Updating %d device(s)", devices.size()));
+
+        ArrayList<ApplicationPacket> packets = new ArrayList<>();
+
+        ArrayList<String> keys = new ArrayList<>();
+        for (Parameter p : Parameter.values()) {
+            keys.add(p.toString());
+        }
+
+        for (ApplianceImpl device : devices.values()) {
+            ApplicationPacket packet = new ApplicationPacket();
+            packet.targetClientId = device.getId();
+            packet.i = 0;
+
+            StatusResponsePack pack = new StatusResponsePack();
+            pack.options = keys.toArray(new String[0]);
+            pack.mac = device.getId();
+            packet.pack = pack;
+
+            packets.add(packet);
+        }
+
+        final AsyncCommunicator comm = new AsyncCommunicator(keyChain);
+        comm.setCommunicationFinishedListener(new AsyncCommunicationFinishedListener() {
+            @Override
+            public void onFinished() {
+                try {
+                    Packet[] responses = comm.get();
+
+                    for (Packet response : responses) {
+                        if (devices.containsKey(response.clientId)) {
+                            devices.get(response.clientId).updateWithDatPack((ChangeOptionRequestPack) response.pack);
+                        }
+                    }
+
+                    sendEvent(DeviceManagerEvent.DEVICE_STATUS_UPDATED);
+
+                } catch (Exception e) {
+                    LOGGER.warning("Failed to get device update result. Error: " + e.getMessage());
+                }
+            }
+        });
+        comm.execute(packets.toArray(new Packet[0]));
+    }
+
+    private void bindDevices(Packet[] scanResponses) throws IOException {
+        ArrayList<ApplicationPacket> requests = new ArrayList<>();
+
+        for (int i = 0; i < scanResponses.length; i++) {
+            Packet response = scanResponses[i];
+
+            if (!(response.pack instanceof DeviceResponsePack devicePack))
+                continue;
+
+            ApplianceImpl device;
+
+            if (!devices.containsKey(response.clientId)) {
+                device = new ApplianceImpl(devicePack.mac, this);
+                devices.put(devicePack.mac, device);
+            } else {
+                device = devices.get(response.clientId);
+            }
+            device.updateWithDevicePack(devicePack);
+
+            if (!keyChain.containsKey(response.clientId)) {
+                LOGGER.info("Binding device: " + devicePack.name);
+
+                ApplicationPacket request = new ApplicationPacket();
+                request.targetClientId = response.clientId;
+                request.pack = new BindRequestPack();
+                request.pack.mac = request.targetClientId;
+                request.i = 1;
+
+                requests.add(request);
+            }
+        }
+
+        final AsyncCommunicator comm = new AsyncCommunicator(keyChain);
+        comm.setCommunicationFinishedListener(new AsyncCommunicationFinishedListener() {
+            @Override
+            public void onFinished() {
+                try {
+                    Packet[] responses = comm.get();
+                    storeDevices(responses);
+                } catch (Exception e) {
+                    LOGGER.fine("Device discovery failed with exception\n" + e);
+                }
+            }
+        });
+        comm.execute(requests.toArray(new Packet[0]));
+    }
+
+    private void storeDevices(Packet[] bindResponses) {
+        for (Packet response : bindResponses) {
+            if (!(response.pack instanceof BindResponsePack pack))
+                continue;
+
+            LOGGER.info("Storing key for device: " + pack.mac);
+            keyChain.addKey(pack.mac, pack.deviceKey);
+        }
+
+        sendEvent(DeviceManagerEvent.DEVICE_LIST_UPDATED);
+        updateDevices();
+    }
+
+    private void sendEvent(DeviceManagerEvent event) {
+        for (DeviceManagerEventListener listener : eventListeners)
+            listener.onEvent(event);
+    }
+}

src/main/java/eu/czsoft/greesdk/DeviceManagerEvent.java

@@ -0,0 +1,6 @@
+package eu.czsoft.greesdk;
+
+public enum DeviceManagerEvent {
+    DEVICE_LIST_UPDATED,
+    DEVICE_STATUS_UPDATED
+}

src/main/java/eu/czsoft/greesdk/DeviceManagerEventListener.java

@@ -0,0 +1,6 @@
+package eu.czsoft.greesdk;
+
+public interface DeviceManagerEventListener {
+
+    void onEvent(DeviceManagerEvent event);
+}

src/main/java/eu/czsoft/greesdk/Unzipped.java

@@ -0,0 +1,12 @@
+package eu.czsoft.greesdk;
+
+public class Unzipped
+{
+    public final String[] keys;
+    public final Integer[] values;
+
+    public Unzipped(String[] keys, Integer[] values) {
+        this.keys = keys;
+        this.values = values;
+    }
+}