iPhone - incoming call / Apple Notification Center Service (ANCS)

[MarkusCosi]

Hallo zusammen,

Hintergrund: Ich würde gerne bei eingehenden Anrufen z.B. Musik auf "Pause" schalten. Nach Beendigung des Anrufs auf "Weiter".

Bekanntlich erlaubt Apple aktuell keinen offiziellen Weg um auf einfache Art und Weise Automatisierungen basierend auf der phone app auszuführen (siehe hier). Android hingegen lässt dies scheinbar zu, siehe hier.
Eine Alternative beim iOS schein ein Widget zu sein welches immer im Hintergrund läuft, siehe hier. Das erscheint mir jedoch nicht besonders sinnvoll und jedenfalls nicht ressourcenschonend. Auch bringt das scheinbar eine Latenz mit sich.

Zuletzt bin ich auf die Möglichkeit gestoßen iOS notifications mit einem ESP32 abzufangen, siehe hier. Das geht wohl über den Apple Notification Center Service (ANCS). Laut Spezifikationen gibt es dabei wohl auch infos zu incoming calls, siehe hier.

Hat schon mal jemand in der Richtung probiert?

Viele Grüße!

[t_heinrich]

Oh wenn sowas klappt wäre echt klasse, mein iPhone ist fast immer nur auf Vibration eingestellt und wenn ich zu Hause bin, verpasse ich dann immer mal wieder Anrufe, weil ich es nicht in der Hosentasche habe.

[MarkusCosi]

Folgenden Code habe ich verwendet (minus die Hardware Button Geschichte): https://github.com/Smartphone-Compan...connection.ino

...leider scheint die ESP32 library für ANCS nicht mehr zu funktionieren, siehe hier. Entsprechend bekam ich eine Reihe kryptischer Fehlermeldungen.

Aber: Im Arduino IDE half ein downgrade des ESP32 boards auf 1.0.6. (siehe hier): Tools → Board → Boards Manager → dann links suchen nach ESP32, dann die Version aus der drop-down liste auswählen.
Dann musste ich noch eine Fehlermeldung beheben die damit zu tun hat, dass python = Python 2 wohl erwartet wurde, ich aber Python 3 installiert habe was per python3 aufgerufen wird. Folgender Befehl behob das und ändert die alte ESP32-Version:

sed -i -e 's/=python /=python3 /g' ~/Library/Arduino15/packages/esp32/hardware/esp32/*/platform.txt

Danach konnte ich das Skript mit baudrate 115200 und Partition auf Large kompilieren und hochladen auf den ESP32. Nachdem ich mich mit dem iPhone bei Bluetooth in das tool eingewählt hatte, und die Anfrage auf Kopplung und Erlaubnis Notifications zu senden bejaht hatte, bekam ich im Serial Monitor alle Anruf Infos eines Testanrufs!

21:05:30.536 -> Got notification: Anrufer Name (aus dem Telefonbuch?)
21:05:30.575 -> Eingehender Anruf
21:05:30.575 -> com.apple.mobilephone
21:05:30.602 -> incoming call

Mit einer schlanken MQTT library (https://www.emqx.com/en/blog/esp32-c...ic-mqtt-broker) sollte das dann vom ESP32 an den Miniserver gehen können, bzw. ggf. direkt auf einen digitalen Eingang per http?

[t_heinrich]

MarkusCosi es wäre soviel leichter, wenn Apple als Kurzbefehl "Eingehender Anruf" zur Verfügung stellen würde.

Aber mal eine ganz andere Idee: man nimmt eine Dual-Sim und ein Android Handy, was dauerhaft zu Hause, mit Strom versorgt und lautlos ist. Wäre zumindest einen Versuch wert.

[MarkusCosi]

Ja, das wäre in der Tat einfacher.
Die Idee mit Android und dual sim ist vllt. nicht schlecht, aber ich fürchte, dass das IFTTT bei Android mittlerweile auch nur gegen Aufpreis dieses Feature erlaubt (siehe hier). Und es wäre ja auch ein zweites Gerät, so wie der ESP32 als "incoming-call-detector" eben auch...

Wie dem auch sei, folgendes funktioniert. Das BLE-Koppeln funktioniert fortan übrigens automatisch und muss nicht erneut doppelt bestätigt werden. Wifi-Aufbau, BLE-connection zum iPhone, MQTT einwahl: alles automatisch. Jeder Anruf triggert ein MQTT publish: "iPhone: incoming call (1)" unter dem topic "eps32".

Das kann man nun in Loxone verwenden... Das Minimalziel wäre also erreicht...

Schön wäre auch ein direktes setzen eines Tasters / Schalters in Loxone wie hier, aber das habe ich auch noch nicht hinbekommen..,

Leider habe ich es auch noch nicht geschafft die Infos vom Call an MQTT zu publishen.. ich scheitere an dieser blöden char-array vs. string Geschichte... für einen Programmierer ist das sicher einfach, aber ich bekomme es einfach nicht hin. (vgl. hier).

Arduino Code: (tested!)
(Edit: siehe neuen Code unten)

[MarkusCosi]

ich habe noch folgendes beim void onNotificationRemoved hinzgefügt um das Ende eines Anrufs (entweder nicht angenommen oder beendet) per MQTT weiterzugeben:

//filter action: only incoming calls (cancelled)
if (notification->category == CategoryIDIncomingCall) {

Serial.println("Removed Call");
//post MQTT message
Serial.println("MQTT publish generic String for Call cancelled");
client.publish(topicCall, "iPhone: incoming call (0)");
Serial.println("---");

}
if (notification->type == "com.apple.mobilephone") {

if (notification->message == "Aktiver Anruf") {

Serial.println("Finished Call");
//post MQTT message
Serial.println("MQTT publish generic String for Call end");
client.publish(topicCall, "iPhone: incoming call (0)");
Serial.println("---");

}

}

Leider scheitere ich an dieser MQTT Geschichte... es funktioniert einmal, und dann nicht mehr. Ich habe das Gefühl, dass es an dieser retain-Sache liegt, bzw. dem QoS=0 und dass gleiche Dinge nicht mehr als einmal geschickt werden. Kann das sein?

[t_heinrich]

MarkusCosi bleib da bitte dran.
Für mich sind das leider alles böhmische Dörfer, aber ich glaube das interessant schon paar mehr Leute hier.

[MarkusCosi]

Folgender Code für einen ESP32 Mikrocontroller funktioniert nun per direkter Eingabe an den Miniserver per Loxone Webservice / API.
Im Endergebnis hat man damit einen ESP32 mit USB-C Stromversorgung, der automatisch sich ins WLAN einwählt, sich automatisch (nach erstmaligem Pairing mit Bestätigung am iPhone) per BLE (Bluetooth) mit dem iPhone verbindet, und bei eingehenden Anrufen einen Schalter in Loxone währen des Klingelns bzw. des Telefonats auf EIN setzt, und bei Beendigung den Schalter auf AUS setzt. Der Schalter geht auch auf ein bei einem ausgehenden Anruf sobald dieser Aktiv (also angenommen) wird!

Dazu muss man in der Loxone Config einen Baustein vom Typ "Schalter" mit dem Namen "iPhone" anlegen. Dazu einen Benutzer anlegen mit dem Namen "ESP32User" und dem Passwort "ESP32UserPW" (sollte man natürlich anpassen). Am besten erstellt man dann noch einen virtuellen Status Baustein und hängt diesen an den Ausgang des Schalters (den man selbst nicht visualisiert). So sieht man dann eben nur den Status und kann mit dem Schalter an sonsten frei weiter programmieren in der Loxone Config.

Anzupassen sind fernerhin die Miniserver IP, die LoxberryIP + MQTT credentials (kein muss, kann auch gestrichen werden da aktuell ohnehin keine zuverlässige Funktion, siehe hier). Beim MQTT Broker des Loxberry wäre dann noch das topic "ESP32/#" zu subscriben, und ggf. der Input per advanced settings im incoming monitor auf "disable cache".

Der Code ist dann auf den ESP zu laden per Arduino IDE und ESP (Version beachten, siehe oben!).. Die LED auf dem Chip zeigt auch den Anruf-Status...

------------------------

Edit: aktueller Code: siehe unten!

[MarkusCosi]

...was jetzt noch fehlt wäre die Möglichkeit mit mehreren iPhones / Geräten sich mit dem ESP32 zu verbinden... Hat jemand eine Idee / Ahnung ob das überhaupt technisch funktioniert? Oder ist das BLE pairing immer, so wie der Name suggeriert, zwischen zwei Parteien only?

[MarkusCosi]

...nach etwas rumstöbern im Netz und ausprobieren habe ich gesehen, dass auch rausgehende Anrufe mit dieser Methode abfangbar sind. Zwar nicht beim Wählen, aber zumindest sobald der Anruf von der Gegenseite angenommen wird und damit aktiv wird. Siehe hier. Es scheint ein feature zu sein, welches von Apple mit iOS 13 hinzugekommen ist und einige gar geärgert hat, siehe hier. Das ganze hat zwar keine Kategorie ID (siehe auch hier), aber man kann die notification über die issuing app (type="com.apple.mobilephone") und die Message = "Aktiver Anruf" eben doch eindeutig identifizieren und so als trigger nutzen.

Jedenfalls ermöglicht dies nun insgesamt eine Umsetzung, bei der sowohl eingehende Anrufe als auch ausgehende Anrufe einen Status beim Miniserver setzen, siehe den aktualisierten Code oben.

Alternativ könnte man bei rausgehenden Anrufen noch bei iOS über Shortcuts → automation gehen, siehe hier. Dh ein Webhook trigger sobald man die phone app öffnet. Das ist aber natürlich nicht sonderlich praktisch…

Was mich noch beschäftigt ist die Frage, ob mehrere iPhones als clients an den BLE server (=ESP32) angeschlossen werden können. Grundsätzlich scheint jedenfalls nichts dagegen zu sprechen, da mehrere notification provider (NP = iPhone) an einen notification client (NC, =ESP32) notifications senden können sollte, und bluetooth mehrere Verbindungen grundsätzlich zulässt, siehe hier, hier, hier, hier. Jedoch scheinen die libraries und die darin definierten BLE Funktionen (in esp32notifications.cpp?)

Leider komme ich hier programmiertechnisch an meine Grenzen. Wenn hier jemand mehr ESP32 Programmiererfahrung hätte, insbes. im Bereich BLE / bluetooth, wäre ich für Hilfe dankbar!

P.S.: ggf. wäre für reconnects zum Bluetooth folgender Trick noch anzuwenden: ESP.restart(); bei BLE disconnects..

[MarkusCosi]

den iPhone connected Status mit BLE habe ich noch als weiteren Schalter + virt. Status Baustein eingebunden, wobei ich den Zustand in der Funktion "onBLEStateChanged" setze, sowie auf EIN bei jedem Erhalt einer Nachricht. Zusätzlich setze ich den BLE Status auf 0 wenn der Ping Baustein mir sagt, dass der ESP32 offline bzw. aus ist (der ESP hat eine feste IP über DHCP bekommen).

Außerdem habe ich noch per oder die Abfragen "notification->type == "com.apple.mobilephone" auf folgendes geändert, um so selbiges bei Face-Time Anrufen zu erreichen:
((notification->type == "com.apple.mobilephone") || (notification->type == "com.apple.facetime"))

und folgendes funktioniert nun zum MQTT publishen des Anrufer Namens:
String MQTTMessage = "Anrufer: ";
MQTTMessage += notification->title;
char* MQTTmessageCString = strdup(MQTTMessage.c_str());
client.publish(topicCallName, MQTTmessageCString);

...so schaltet nun bei jedem Anruf die Musik auf Pause und geht nach Ende des Anrufs weiter. Flankenerkennung geht an einen EIB-Schalter der zwischen Play/Pause per Yamaha MusicCast API schaltet...

[MarkusCosi]

...nach etwas Probieren habe ich den code noch etwas angepasst und in der Loxone Config eingestellt, dass der ESP einen Fern-Restart bekommt, wenn 1) der ESP online ist + 2) das iPhone im Access Point eingewählt ist wo auch der ESP Empfang haben sollte (nutze das neue Wifi Presence Unifi Plugin für den Loxberry) + 3) BLE keine Verbindung hat. Das schaltet einen Impuls-Geber frei (Off-Eingang geht Aus, Impuls alle 30min) der wiederum einen http-Befehl <<IP>>/R schaltet um den ESP neu zu starten. Das hilft wenn das Telefon mal außer Reichweite war um einen reconnect zu ermöglichen...

Anbei der Arduino-Code (grüne Einträge sind anzupassen!):

// iPhone: incoming calls to Loxone
#include "esp32notifications.h" //Apple ANCS support, see https://www.github.com/Smartphone-Co...ifications.git
#include <WiFi.h> //Wifi support
#include <WiFiClient.h>
#include <HTTPClient.h> //Wifi server support
#include <PubSubClient.h> //MQTT

//On-chip LED GPIO (depends on used ESP32 board)
int LED_BUILTIN = 2;

//Wifi SSID and password
const char* ssid = "YourSSID";
const char* password = "YourPW";
unsigned long previousMillis = 0;
unsigned long interval = 30000;
WiFiServer server(80);

//Loxone Miniserver + credentials for user authorized on switch(es)
String serverName = "http://YourMiniserverIP";
const char* MiniserverUser = "YourESPUser";
const char* MiniserverPW = "YourESPUserPW";
String LoxoneCallSwitchName = "iPhone";
String LoxoneBLESwitchName = "iPhoneBLE";

// MQTT Broker: Loxberry
const char *mqtt_broker = "LoxBerryIP";
const char *topic = "esp32";
const char *topicCall = "esp32/Call";
const char *topicCallName = "esp32/CallName";
const char *mqtt_username = "YourLoxBerryMQTTUser";
const char *mqtt_password = "YourLoxBerryMQTTUserPW";
const int mqtt_port = 1883;

// Create an interface to the BLE notification library
BLENotifications notifications;
WiFiClient espClient;
PubSubClient client(espClient);

// This callback will be called when a Bluetooth LE connection is made or broken.
// You can update the ESP 32's UI or take other action here.
void onBLEStateChanged(BLENotifications::State state) {

switch(state) {

case BLENotifications::StateConnected:

Serial.println("StateConnected - connected to iPhone");
LoxoneSwitch(1, LoxoneBLESwitchName);
break;

case BLENotifications::StateDisconnected:

Serial.println("StateDisconnected - disconnected from iPhone");
notifications.startAdvertising();
LoxoneSwitch(0, LoxoneBLESwitchName);
ESP.restart(); // solves reconnect issue | alternative: trigger restart via http command <<IP>>/R
break;

}

}

// Call (initiated & active) or incoming
// A notification arrived from the mobile device, i.e. a social media notification or incoming call.
// parameters: notification: an Arduino-friendly structure containing notification information.
void onNotificationArrived(const ArduinoNotification * notification, const Notification * rawNotificationData) {

//filter out buffered / old notifications
if((notification->eventFlags & ANCS::EventFlags::EventFlagPreExisting) != 0) {

Serial.print("Received PRE-EXISTING notification from app: ");
Serial.print(notification->type);
Serial.println(" -> discarded");

} else {

//serial print any new incoming notification
Serial.print("Got new notification: title: ");
Serial.print(notification->title); // The title, ie name of who sent the message
Serial.print(", message: ");
Serial.print(notification->message); // The detail, ie "be home for dinner at 7".
Serial.print(", type: ");
Serial.print(notification->type); // Which app sent it
Serial.print(", category: ");
Serial.println(notifications.getNotificationCatego ryDescription(notification->category)); // ie "social media"
Serial.print("eventFlags: ");
Serial.println(notification->eventFlags);

//filter action: incoming call
if (notification->category == CategoryIDIncomingCall) {

Serial.println("Incoming Call");

//post MQTT message
Serial.println("MQTT publish generic String for incoming call");
client.subscribe(topicCall);
client.publish(topicCall, "1");
Serial.println("---");

//post MQTT message with name/number from caller (depends on phone book)
String MQTTMessage = "Anrufer: ";
MQTTMessage += notification->title;
char* MQTTmessageCString = strdup(MQTTMessage.c_str());
client.publish(topicCallName, MQTTmessageCString);

// set Call-Switch in Loxone
LoxoneSwitch(1, LoxoneCallSwitchName);

//LED on
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)

}

//filter: outgoing call / face-time becomes active
if ((notification->type == "com.apple.mobilephone") || (notification->type == "com.apple.facetime")) {

if (notification->message == "Aktiver Anruf") {

Serial.println("Started Call");

//post MQTT message
Serial.println("MQTT publish generic String for started call");
client.subscribe(topicCall);
client.publish(topicCall, "1");
Serial.println("---");

// set Call Switch in Loxone
LoxoneSwitch(1, LoxoneCallSwitchName);

//LED on
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)

}

}

}

}

// A notification was cleared
void onNotificationRemoved(const ArduinoNotification * notification, const Notification * rawNotificationData) {

Serial.print("Removed notification: title: ");
Serial.print(notification->title);
Serial.print(", message: ");
Serial.print(notification->message);
Serial.print(", type: ");
Serial.print(notification->type);
Serial.print(", category: ");
Serial.println(notifications.getNotificationCatego ryDescription(notification->category)); // ie "social media"

//filter: incoming call cancelled
if (notification->category == CategoryIDIncomingCall) {

Serial.println("Removed Call");

//post MQTT message
Serial.println("MQTT publish generic String for declined Call");
client.subscribe(topicCall);
client.publish(topicCall, "0");
Serial.println("---");

//Set Call Swith in Loxone
LoxoneSwitch(0, LoxoneCallSwitchName);

//LED Off
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW

}

//filter: call ended

if ((notification->type == "com.apple.mobilephone") || (notification->type == "com.apple.facetime")) {

if (notification->message == "Aktiver Anruf") {

Serial.println("Finished Call");

//post MQTT message
Serial.println("MQTT publish generic String for Call end");
client.subscribe(topicCall);
client.publish(topicCall, "0");
Serial.println("---");

//Set Call Swith in Loxone
LoxoneSwitch(0, LoxoneCallSwitchName);

//LED Off
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW

}

}

}

//function to set Switch in Loxone
void LoxoneSwitch(int OnOff, String SwithStr) {

HTTPClient http;
String serverPath = serverName + "/dev/sps/io/";
serverPath = serverPath + SwithStr + "/";
if (OnOff == 0) {

serverPath = serverPath + "Aus";
Serial.println("--- sending GET (Aus) to Miniserver");

} else {

serverPath = serverPath + "Ein";
Serial.println("--- sending GET (Ein) to Miniserver");

}
http.setAuthorization(MiniserverUser, MiniserverPW);
http.begin(serverPath.c_str());
int httpResponseCode = http.GET();
if (httpResponseCode>0) {

Serial.print("HTTP Response code: ");
Serial.println(httpResponseCode);
String payload = http.getString();
Serial.println(payload);

} else {

Serial.print("Error code: ");
Serial.println(httpResponseCode);

}
// Free resources
http.end();

}

// Standard Arduino function which is called once when the device first starts up
void setup() {

// Setup for Serial Monitor (when connected to Arduino IDE: Tools -> Serial Monitor)
Serial.begin(9600);
while(!Serial) {

delay(10);

}

// Initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);

// Connect to WiFi
Serial.println("\nConnecting to WiFi");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while(WiFi.status() != WL_CONNECTED){

Serial.print(".");
delay(500);

}
Serial.print("\nConnected to the WiFi network: ");
Serial.print(String(ssid));
Serial.print(" | local ESP32 IP: ");
Serial.print(WiFi.localIP());
Serial.print(" | RSSI: ");
Serial.println(WiFi.RSSI());

//start server to allow control via http commands
server.begin();

// Connect to MQTT
client.setServer(mqtt_broker, mqtt_port);
client.setCallback(callback);
while (!client.connected()) {

String client_id = "esp32-client-";
client_id += String(WiFi.macAddress());
Serial.printf("The client %s connects to the public MQTT broker\n", client_id.c_str());
if (client.connect(client_id.c_str(), mqtt_username, mqtt_password)) {

Serial.println("Loxberry MQTT broker connected");

} else {

Serial.print("failed with state ");
Serial.println(client.state());
delay(2000);

}

}
// Test-Publish via MQTT and subscribe
client.publish(topic, "ESP32 now publishing to MQTT");
client.subscribe(topic);

// Set up the BLENotification library
notifications.begin("iPhone Call Detector");
notifications.setConnectionStateChangedCallback(on BLEStateChanged);
notifications.setNotificationCallback(onNotificati onArrived);
notifications.setRemovedCallback(onNotificationRem oved);

// Blink LED on Chip once on Start
digitalWrite(LED_BUILTIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // LED on for 1sec
digitalWrite(LED_BUILTIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait / off for 1sec

}

// MQTT receive messages
void callback(char *topic, byte *payload, unsigned int length) {

Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
for (int i = 0; i < length; i++) {

Serial.print((char) payload[i]);

}
Serial.println();
Serial.println("-----------------------");

}

// Standard Arduino function that is called in an endless loop after setup
void loop() {

// if WiFi is down, try reconnecting every interval seconds
unsigned long currentMillis = millis(); //works for ca. 50 days before reset to 0
if ((WiFi.status() != WL_CONNECTED) && (currentMillis - previousMillis >= interval)) {

Serial.print(millis());
Serial.println("Reconnecting to WiFi...");
WiFi.disconnect();
WiFi.reconnect();
previousMillis = currentMillis;

}
if (currentMillis - previousMillis < 0) {

previousMillis = currentMillis;

}

//get restart command from external http command to server
WiFiClient client = server.available();
if (client) {

Serial.println("New Client");
String currentLine = "";
while (client.connected()) {

if (client.available()) {

char c = client.read();
Serial.write(c);
currentLine += c;
if (currentLine.endsWith("GET /R")) {

Serial.println(" command received to restart ESP32");
LoxoneSwitch(0, LoxoneBLESwitchName);
ESP.restart();

}

}

}
client.stop();
Serial.println("Client disconnected");

}

}