353 lines
12 KiB
Dart
353 lines
12 KiB
Dart
part of 'main.dart';
|
|
|
|
class HADataProvider {
|
|
String _hassioAPIEndpoint;
|
|
String _hassioPassword;
|
|
String _hassioAuthType;
|
|
IOWebSocketChannel _hassioChannel;
|
|
int _currentMessageId = 0;
|
|
int _statesMessageId = 0;
|
|
int _servicesMessageId = 0;
|
|
int _subscriptionMessageId = 0;
|
|
int _configMessageId = 0;
|
|
Map _entitiesData = {};
|
|
Map _servicesData = {};
|
|
Map _uiStructure = {};
|
|
Map _instanceConfig = {};
|
|
Completer _fetchCompleter;
|
|
Completer _statesCompleter;
|
|
Completer _servicesCompleter;
|
|
Completer _configCompleter;
|
|
Timer _fetchingTimer;
|
|
List _topBadgeDomains = ["alarm_control_panel", "binary_sensor", "device_tracker", "updater", "sun", "timer", "sensor"];
|
|
|
|
Map get entities => _entitiesData;
|
|
Map get services => _servicesData;
|
|
Map get uiStructure => _uiStructure;
|
|
Map get instanceConfig => _instanceConfig;
|
|
|
|
HADataProvider(String url, String password, String authType) {
|
|
_hassioAPIEndpoint = url;
|
|
_hassioPassword = password;
|
|
_hassioAuthType = authType;
|
|
}
|
|
|
|
Future fetch() {
|
|
if ((_fetchCompleter != null) && (!_fetchCompleter.isCompleted)) {
|
|
TheLogger.log("Warning","Previous fetch is not complited");
|
|
} else {
|
|
//TODO: Fetch timeout timer. Should be removed after #21 fix
|
|
_fetchingTimer = Timer(Duration(seconds: 15), () {
|
|
closeConnection();
|
|
_fetchCompleter.completeError({"errorCode" : 1,"errorMessage": "Connection timeout"});
|
|
});
|
|
_fetchCompleter = new Completer();
|
|
_reConnectSocket().then((r) {
|
|
_getData();
|
|
}).catchError((e) {
|
|
_finishFetching(e);
|
|
});
|
|
}
|
|
return _fetchCompleter.future;
|
|
}
|
|
|
|
closeConnection() {
|
|
if (_hassioChannel?.closeCode == null) {
|
|
_hassioChannel?.sink?.close();
|
|
}
|
|
_hassioChannel = null;
|
|
}
|
|
|
|
Future _reConnectSocket() {
|
|
var _connectionCompleter = new Completer();
|
|
if ((_hassioChannel == null) || (_hassioChannel.closeCode != null)) {
|
|
TheLogger.log("Debug","Socket connecting...");
|
|
_hassioChannel = IOWebSocketChannel.connect(_hassioAPIEndpoint);
|
|
_hassioChannel.stream.handleError((e) {
|
|
TheLogger.log("Error","Unhandled socket error: ${e.toString()}");
|
|
});
|
|
_hassioChannel.stream.listen((message) =>
|
|
_handleMessage(_connectionCompleter, message));
|
|
} else {
|
|
_connectionCompleter.complete();
|
|
}
|
|
return _connectionCompleter.future;
|
|
}
|
|
|
|
_getData() {
|
|
_getConfig().then((result) {
|
|
_getStates().then((result) {
|
|
_getServices().then((result) {
|
|
_finishFetching(null);
|
|
}).catchError((e) {
|
|
_finishFetching(e);
|
|
});
|
|
}).catchError((e) {
|
|
_finishFetching(e);
|
|
});
|
|
}).catchError((e) {
|
|
_finishFetching(e);
|
|
});
|
|
}
|
|
|
|
_finishFetching(error) {
|
|
_fetchingTimer.cancel();
|
|
if (error != null) {
|
|
_fetchCompleter.completeError(error);
|
|
} else {
|
|
_fetchCompleter.complete();
|
|
}
|
|
}
|
|
|
|
_handleMessage(Completer connectionCompleter, String message) {
|
|
var data = json.decode(message);
|
|
//TheLogger.log("Debug","[Received] => Message type: ${data['type']}");
|
|
if (data["type"] == "auth_required") {
|
|
_sendMessageRaw('{"type": "auth","$_hassioAuthType": "$_hassioPassword"}');
|
|
} else if (data["type"] == "auth_ok") {
|
|
_sendSubscribe();
|
|
connectionCompleter.complete();
|
|
} else if (data["type"] == "auth_invalid") {
|
|
connectionCompleter.completeError({"errorCode": 6, "errorMessage": "${data["message"]}"});
|
|
} else if (data["type"] == "result") {
|
|
if (data["id"] == _configMessageId) {
|
|
_parseConfig(data);
|
|
} else if (data["id"] == _statesMessageId) {
|
|
_parseEntities(data);
|
|
} else if (data["id"] == _servicesMessageId) {
|
|
_parseServices(data);
|
|
} else if (data["id"] == _currentMessageId) {
|
|
TheLogger.log("Debug","Request id:$_currentMessageId was successful");
|
|
}
|
|
} else if (data["type"] == "event") {
|
|
if ((data["event"] != null) && (data["event"]["event_type"] == "state_changed")) {
|
|
_handleEntityStateChange(data["event"]["data"]);
|
|
} else if (data["event"] != null) {
|
|
TheLogger.log("Warning","Unhandled event type: ${data["event"]["event_type"]}");
|
|
} else {
|
|
TheLogger.log("Error","Event is null: $message");
|
|
}
|
|
} else {
|
|
TheLogger.log("Warning","Unknown message type: $message");
|
|
}
|
|
}
|
|
|
|
void _sendSubscribe() {
|
|
_incrementMessageId();
|
|
_subscriptionMessageId = _currentMessageId;
|
|
_sendMessageRaw('{"id": $_subscriptionMessageId, "type": "subscribe_events", "event_type": "state_changed"}');
|
|
}
|
|
|
|
Future _getConfig() {
|
|
_configCompleter = new Completer();
|
|
_incrementMessageId();
|
|
_configMessageId = _currentMessageId;
|
|
_sendMessageRaw('{"id": $_configMessageId, "type": "get_config"}');
|
|
|
|
return _configCompleter.future;
|
|
}
|
|
|
|
Future _getStates() {
|
|
_statesCompleter = new Completer();
|
|
_incrementMessageId();
|
|
_statesMessageId = _currentMessageId;
|
|
_sendMessageRaw('{"id": $_statesMessageId, "type": "get_states"}');
|
|
|
|
return _statesCompleter.future;
|
|
}
|
|
|
|
Future _getServices() {
|
|
_servicesCompleter = new Completer();
|
|
_incrementMessageId();
|
|
_servicesMessageId = _currentMessageId;
|
|
_sendMessageRaw('{"id": $_servicesMessageId, "type": "get_services"}');
|
|
|
|
return _servicesCompleter.future;
|
|
}
|
|
|
|
_incrementMessageId() {
|
|
_currentMessageId += 1;
|
|
}
|
|
|
|
_sendMessageRaw(String message) {
|
|
if (message.indexOf('"type": "auth"') > 0) {
|
|
TheLogger.log("Debug", "[Sending] ==> auth request");
|
|
} else {
|
|
TheLogger.log("Debug", "[Sending] ==> $message");
|
|
}
|
|
_hassioChannel.sink.add(message);
|
|
}
|
|
|
|
void _handleEntityStateChange(Map eventData) {
|
|
//TheLogger.log("Debug", "Parsing new state for ${eventData['entity_id']}");
|
|
if (eventData["new_state"] == null) {
|
|
TheLogger.log("Error", "No new_state found");
|
|
} else {
|
|
var parsedEntityData = _parseEntity(eventData["new_state"]);
|
|
String entityId = parsedEntityData["entity_id"];
|
|
if (_entitiesData[entityId] == null) {
|
|
_entitiesData[entityId] = parsedEntityData;
|
|
} else {
|
|
_entitiesData[entityId].addAll(parsedEntityData);
|
|
}
|
|
eventBus.fire(new StateChangedEvent(eventData["entity_id"]));
|
|
}
|
|
}
|
|
|
|
void _parseConfig(Map data) {
|
|
if (data["success"] == true) {
|
|
_instanceConfig = Map.from(data["result"]);
|
|
_configCompleter.complete();
|
|
} else {
|
|
_configCompleter.completeError({"errorCode": 2, "errorMessage": data["error"]["message"]});
|
|
}
|
|
}
|
|
|
|
void _parseServices(response) {
|
|
if (response["success"] == false) {
|
|
_servicesCompleter.completeError({"errorCode": 4, "errorMessage": response["error"]["message"]});
|
|
return;
|
|
}
|
|
try {
|
|
Map data = response["result"];
|
|
Map result = {};
|
|
TheLogger.log("Debug","Parsing ${data.length} Home Assistant service domains");
|
|
data.forEach((domain, services) {
|
|
result[domain] = Map.from(services);
|
|
services.forEach((serviceName, serviceData) {
|
|
if (_entitiesData["$domain.$serviceName"] != null) {
|
|
result[domain].remove(serviceName);
|
|
}
|
|
});
|
|
});
|
|
_servicesData = result;
|
|
_servicesCompleter.complete();
|
|
} catch (e) {
|
|
//TODO hadle it properly
|
|
TheLogger.log("Error","Error parsing services. But they are not used :-)");
|
|
_servicesCompleter.complete();
|
|
}
|
|
}
|
|
|
|
void _parseEntities(response) async {
|
|
_entitiesData.clear();
|
|
_uiStructure.clear();
|
|
if (response["success"] == false) {
|
|
_statesCompleter.completeError({"errorCode": 3, "errorMessage": response["error"]["message"]});
|
|
return;
|
|
}
|
|
List data = response["result"];
|
|
TheLogger.log("Debug","Parsing ${data.length} Home Assistant entities");
|
|
List<String> viewsList = [];
|
|
data.forEach((entity) {
|
|
try {
|
|
var composedEntity = _parseEntity(entity);
|
|
|
|
if (composedEntity["attributes"] != null) {
|
|
if ((composedEntity["domain"] == "group") &&
|
|
(composedEntity["attributes"]["view"] == true)) {
|
|
viewsList.add(composedEntity["entity_id"]);
|
|
}
|
|
}
|
|
_entitiesData[entity["entity_id"]] = composedEntity;
|
|
} catch (error) {
|
|
TheLogger.log("Error","Error parsing entity: ${entity['entity_id']}");
|
|
}
|
|
});
|
|
|
|
//Gethering information for UI
|
|
TheLogger.log("Debug","Gethering views");
|
|
int viewCounter = 0;
|
|
viewsList.forEach((viewId) { //Each view
|
|
try {
|
|
Map viewStructure = {};
|
|
viewCounter += 1;
|
|
var viewGroupData = _entitiesData[viewId];
|
|
if ((viewGroupData != null) && (viewGroupData["attributes"] != null)) {
|
|
viewStructure["groups"] = {};
|
|
viewStructure["state"] = "on";
|
|
viewStructure["entity_id"] = viewGroupData["entity_id"];
|
|
viewStructure["badges"] = {"children": []};
|
|
viewStructure["attributes"] = {
|
|
"icon": viewGroupData["attributes"]["icon"]
|
|
};
|
|
|
|
viewGroupData["attributes"]["entity_id"].forEach((
|
|
entityId) { //Each entity or group in view
|
|
Map newGroup = {};
|
|
if (_entitiesData[entityId] != null) {
|
|
Map cardOrEntityData = _entitiesData[entityId];
|
|
String domain = cardOrEntityData["domain"];
|
|
if (domain != "group") {
|
|
if (_topBadgeDomains.contains(domain)) {
|
|
viewStructure["badges"]["children"].add(entityId);
|
|
} else {
|
|
String autoGroupID = "$domain.$domain$viewCounter";
|
|
if (viewStructure["groups"]["$autoGroupID"] == null) {
|
|
newGroup["entity_id"] = "$domain.$domain$viewCounter";
|
|
newGroup["friendly_name"] = "$domain";
|
|
newGroup["children"] = [];
|
|
newGroup["children"].add(entityId);
|
|
viewStructure["groups"]["$autoGroupID"] =
|
|
Map.from(newGroup);
|
|
} else {
|
|
viewStructure["groups"]["$autoGroupID"]["children"].add(
|
|
entityId);
|
|
}
|
|
}
|
|
} else {
|
|
newGroup["entity_id"] = entityId;
|
|
newGroup["friendly_name"] =
|
|
(cardOrEntityData['attributes'] != null)
|
|
? (cardOrEntityData['attributes']['friendly_name'] ??
|
|
"")
|
|
: "";
|
|
newGroup["children"] = List<String>();
|
|
cardOrEntityData["attributes"]["entity_id"].forEach((
|
|
groupedEntityId) {
|
|
newGroup["children"].add(groupedEntityId);
|
|
});
|
|
viewStructure["groups"]["$entityId"] = Map.from(newGroup);
|
|
}
|
|
} else {
|
|
TheLogger.log("Warning", "Unknown entity inside view: $entityId");
|
|
}
|
|
});
|
|
_uiStructure[viewId.split(".")[1]] = viewStructure;
|
|
} else {
|
|
TheLogger.log("Warning", "No state or attributes found for view: $viewId");
|
|
}
|
|
|
|
} catch (error) {
|
|
TheLogger.log("Error","Error parsing view: $viewId");
|
|
}
|
|
});
|
|
_statesCompleter.complete();
|
|
}
|
|
|
|
Map _parseEntity(rawData) {
|
|
var composedEntity = Map.from(rawData);
|
|
String entityDomain = rawData["entity_id"].split(".")[0];
|
|
composedEntity["display_name"] = "${rawData["attributes"]!=null ? rawData["attributes"]["friendly_name"] ?? rawData["attributes"]["name"] : "_"}";
|
|
composedEntity["domain"] = entityDomain;
|
|
return composedEntity;
|
|
}
|
|
|
|
Future callService(String domain, String service, String entity_id) {
|
|
var sendCompleter = Completer();
|
|
//TODO: Send service call timeout timer. Should be removed after #21 fix
|
|
Timer _sendTimer = Timer(Duration(seconds: 7), () {
|
|
sendCompleter.completeError({"errorCode" : 8,"errorMessage": "Connection timeout"});
|
|
});
|
|
_reConnectSocket().then((r) {
|
|
_incrementMessageId();
|
|
_sendMessageRaw('{"id": $_currentMessageId, "type": "call_service", "domain": "$domain", "service": "$service", "service_data": {"entity_id": "$entity_id"}}');
|
|
_sendTimer.cancel();
|
|
sendCompleter.complete();
|
|
}).catchError((e){
|
|
_sendTimer.cancel();
|
|
sendCompleter.completeError(e);
|
|
});
|
|
return sendCompleter.future;
|
|
}
|
|
} |