Esp8266 won't connect to Amazon Alexa

As the title says, whenever I try to connect to my esp8266 via searching for devices over the network, it responds with no devices found, even though both are communicating with the network. I have seen other people having this problem, but none of the given solutions have worked for me. My code is down below, though obviously everything compiles and uploads. I have tried not using fauxmoESP, using it on 3.1.1, and using it on 2.3.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <WiFiUdp.h>
#include
#include<SoftwareSerial.h>
#include<Servo.h>
#include <ESPAsyncTCP.h>
#include "fauxmoESP.h"

#define D4 2

void prepareIds();
boolean connectWifi();
boolean connectUDP();
void startHttpServer();
void moveServo();
//void turnOffRelay();
//
//
//
// Network settings that need to be modified to get alexa to work for my stuff specifically
const char ssid = "";
const char password = "";
String device_name= "The Thing";// name of the device Alexa will turn on for me
// local port to listen on
//
//
/**/

unsigned int localPort = 1900; // local port to listen on

WiFiUDP UDP;
boolean udpConnected = false;
IPAddress ipMulti(239, 255, 255, 250);
unsigned int portMulti = 1900; // local port to listen on

ESP8266WebServer HTTP(80);

boolean wifiConnected = false;

char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,

String serial;
String persistent_uuid;

Servo servo;
const uint8_t servoPin = D4;
//const byte servoPin = 7; - for the arduino previously
//const int relayPin = BUILTIN_LED; ------------------------------------------------------------------------------------------------

boolean cannotConnectToWifi = false;

//need to setup web server ----------------------------------------------

void setup() {

servo.attach(servoPin);
//Serial.begin(9600); - original
Serial.begin(115200);

// Setup Relay
pinMode(servoPin, OUTPUT); //----------------------------------------------------------------------------------------------------

prepareIds();

// Initialise wifi connection
wifiConnected = connectWifi();

// only proceed if wifi connection successful
if(wifiConnected){
udpConnected = connectUDP();

if (udpConnected){
  // initialise pins if needed 
  startHttpServer();
}
}
}

void loop() {

HTTP.handleClient();
delay(1);

// if there's data available, read a packet
// check if the WiFi and UDP connections were successful
if(wifiConnected){
if(udpConnected){
// if there’s data available, read a packet
int packetSize = UDP.parsePacket();

  if(packetSize) {
    Serial.println("");
    Serial.print("Received packet of size ");
    Serial.println(packetSize);
    Serial.print("From ");
    IPAddress remote = UDP.remoteIP();
    
    for (int i =0; i < 4; i++) {
      Serial.print(remote[i], DEC);
      if (i < 3) {
        Serial.print(".");
      }
    }
    
    Serial.print(", port ");
    Serial.println(UDP.remotePort());
    
    int len = UDP.read(packetBuffer, 255);
    
    if (len > 0) {
        packetBuffer[len] = 0;
    }

    String request = packetBuffer;
    Serial.println("Request:");
    Serial.println(request);
     
    if(request.indexOf('M-SEARCH') > 0) {
        if(request.indexOf("urn:Belkin:device:**") > 0) {
            Serial.println("Responding to search request ...");
            respondToSearch();
        }
    }
  }
    
  delay(10);
}
} else {
// Turn on/off to indicate cannot connect ..
}
}

void prepareIds() {
uint32_t chipId = ESP.getChipId();
Serial.println("ChipId");
Serial.println(chipId);
char uuid[64];
sprintf_P(uuid, PSTR("38323636-4558-4dda-9188-cda0e6%02x%02x%02x"),
(uint16_t) ((chipId >> 16) & 0xff),
(uint16_t) ((chipId >> 8) & 0xff),
(uint16_t) chipId & 0xff);

serial = String(uuid);
persistent_uuid = "Socket-1_0-" + serial;
//device_name = "box";
}

void respondToSearch() {
Serial.println("");
Serial.print("Sending response to ");
Serial.println(UDP.remoteIP());
Serial.print("Port : ");
Serial.println(UDP.remotePort());

IPAddress localIP = WiFi.localIP();
char s[16];
sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

String response = 
     "HTTP/1.1 200 OK\r\n"
     "CACHE-CONTROL: max-age=86400\r\n"
     "DATE: Fri, 15 Apr 2016 04:56:29 GMT\r\n"
     "EXT:\r\n"
     "LOCATION: http://" + String(s) + ":80/setup.xml\r\n"
     "OPT: \"http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n"
     "01-NLS: b9200ebb-736d-4b93-bf03-835149d13983\r\n"
     "SERVER: Unspecified, UPnP/1.0, Unspecified\r\n"
     "ST: urn:Belkin:device:**\r\n"
     "USN: uuid:" + persistent_uuid + "::urn:Belkin:device:**\r\n"
     "X-User-Agent: redsonic\r\n\r\n";

UDP.beginPacket(UDP.remoteIP(), UDP.remotePort());
UDP.write(response.c_str());
UDP.endPacket();                    

 Serial.println("Response sent !");
}

void startHttpServer() {
HTTP.on("/index.html", HTTP_GET, {
Serial.println("Got Request index.html ...\n");
HTTP.send(200, "text/plain", "Hello World!");
});

HTTP.on("/upnp/control/basicevent1", HTTP_POST, []() {
  Serial.println("########## Responding to  /upnp/control/basicevent1 ... ##########");      

  for (int x=0; x <= HTTP.args(); x++) {
    Serial.println(HTTP.arg(x));
  }

  String request = HTTP.arg(0);      
  Serial.print("request:");
  Serial.println(request);

  if(request.indexOf("<BinaryState>1</BinaryState>") > 0) {
      Serial.println("Got Turn on request");
      moveServo();
  }
// if(request.indexOf("0") > 0) {
// Serial.println("Got Turn off request");
// turnOffRelay();
// }

  HTTP.send(200, "text/plain", "");
});

HTTP.on("/eventservice.xml", HTTP_GET, [](){
  Serial.println(" ########## Responding to eventservice.xml ... ########\n");
  String eventservice_xml = "<?scpd xmlns=\"urn:Belkin:service-1-0\"?>"
        "<actionList>"
          "<action>"
            "<name>SetBinaryState</name>"
            "<argumentList>"
              "<argument>"
                "<retval/>"
                "<name>BinaryState</name>"
                "<relatedStateVariable>BinaryState</relatedStateVariable>"
                "<direction>in</direction>"
              "</argument>"
            "</argumentList>"
             "<serviceStateTable>"
              "<stateVariable sendEvents=\"yes\">"
                "<name>BinaryState</name>"
                "<dataType>Boolean</dataType>"
                "<defaultValue>0</defaultValue>"
              "</stateVariable>"
              "<stateVariable sendEvents=\"yes\">"
                "<name>level</name>"
                "<dataType>string</dataType>"
                "<defaultValue>0</defaultValue>"
              "</stateVariable>"
            "</serviceStateTable>"
          "</action>"
        "</scpd>\r\n"
        "\r\n";
        
  HTTP.send(200, "text/plain", eventservice_xml.c_str());
});

HTTP.on("/setup.xml", HTTP_GET, [](){
  Serial.println(" ########## Responding to setup.xml ... ########\n");

  IPAddress localIP = WiFi.localIP();
  char s[16];
  sprintf(s, "%d.%d.%d.%d", localIP[0], localIP[1], localIP[2], localIP[3]);

  String setup_xml = "<?xml version=\"1.0\"?>"
        "<root>"
         "<device>"
            "<deviceType>urn:Belkin:device:controllee:1</deviceType>"
            "<friendlyName>"+ device_name +"</friendlyName>"
            "<manufacturer>Belkin International Inc.</manufacturer>"
            "<modelName>Emulated Socket</modelName>"
            "<modelNumber>3.1415</modelNumber>"
            "<UDN>uuid:"+ persistent_uuid +"</UDN>"
            "<serialNumber>221517K0101769</serialNumber>"
            "<binaryState>0</binaryState>"
            "<serviceList>"
              "<service>"
                  "<serviceType>urn:Belkin:service:basicevent:1</serviceType>"
                  "<serviceId>urn:Belkin:serviceId:basicevent1</serviceId>"
                  "<controlURL>/upnp/control/basicevent1</controlURL>"
                  "<eventSubURL>/upnp/event/basicevent1</eventSubURL>"
                  "<SCPDURL>/eventservice.xml</SCPDURL>"
              "</service>"
          "</serviceList>" 
          "</device>"
        "</root>\r\n"
        "\r\n";
        
    HTTP.send(200, "text/xml", setup_xml.c_str());
    
    Serial.print("Sending :");
    Serial.println(setup_xml);
});

HTTP.begin();  
Serial.println("HTTP Server started ..");
}

// connect to wifi – returns true if successful or false if not
boolean connectWifi(){
boolean state = true;
int i = 0;

WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
Serial.println("");
Serial.println("Connecting to WiFi");

// Wait for connection
Serial.print("Connecting ...");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
if (i > 10){
state = false;
break;
}
i++;
}

if (state){
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
else {
Serial.println("");
Serial.println("Connection failed.");
}

return state;
}

boolean connectUDP(){
boolean state = false;

Serial.println("");
Serial.println("Connecting to UDP");

if(UDP.beginMulticast(WiFi.localIP(), ipMulti, portMulti)) {
Serial.println("Connection successful");
state = true;
}
else{
Serial.println("Connection failed");
}

return state;
}

void moveServo() {
//digitalWrite(servoPin, LOW); //Do I even need this line --------------------------------------

// moves the servo into the correct position (TBD)
servo.write(180);

delay(1500);
servo.write(0);

}

Any thoughts would be highly appreciated!

This "tutorial" has a working software solution. I'd ignore the rest and check out the software.