Skype verwenden um Nachrichten von einem Expert Advisor zu senden

Einführung

Skype ist ein Telekommunikationsprogramm, dass, zusammen mit Chats, Menschen ermöglicht über das Internet zu telefonieren. Einer der wichtigsten Vorteile von Skype, verglichen mit anderen Programmen dieser Art, ist ein Zugang zu echten Mobilfunknetzbetreibern. Beziehungsweise kann man ein echtes Handy anrufen, SMS versenden, und so weiter. Es gibt auch eine Skype Version für Mobiltelefone. Man kann das Geld für SMS-Versenden sparen, da das Versenden von normalen Nachrichten innerhalb des Programms absolut kostenlos ist. Grundsätzlich muss das Mobiltelefon mit einem Betriebssystem arbeiten. Nun, jetzt ist es möglich vollständig mobil zu sein, wenn dies notwendig ist. Und es ist diese Möglichkeit, die viele Menschen heute nutzen.

Wer und Warum Kann Dies Benötigen?

Trader können nicht immer vor ihrem Trading-Terminal sitzen und beobachten wie das Trading sich entwickelt, noch muss er/sie dies machen. Allerdings wäre es großartig, in der Lage zu sein manchmal Signale zu empfangen, die Trader über die Aktionen des Expert Advisors informieren, oder über den Zustand des Marktes in bestimmten Momenten. Warum soll er oder sie diese Informationen nicht auf dem Mobiltelefon empfangen?

Welche Art von Informationen zu Erhalten Wäre Nützlich?

Informationen, die über die Verwendung von Nachrichten in einem Mobiltelefon erhalten werden können, kann man in zwei Gruppen einteilen:

1. aktuelle Daten, die nichts beeinflussen und praktisch die gleichen sind wie in der Protokolldatei,
2. nützliche Infos, die für den Trader hilfreich sein werden, genau in dem Moment, in dem sie eintreffen

Betrachten wir Beispiele für aktuelle Daten:

• Zustand einer Order. Wenn eine Order eröffnet wurde, in welche Richtung, welche Stopps wurden für sie zugewiesen, usw., wann wurde sie geschlossen, aus welchen Gründen, mit einem Verlust oder mit einem Gewinn, usw.
• Verschiedene Marktzustände. Zum Beispiel, wenn ein Indikator ein bestimmtes Niveau erreicht oder ein Trend die Richtung ändert.

Nützliche Informationen:

• Fehlermeldung. Alle Programmierer sind Menschen, und manchmal treten unangenehme Situationen auf, wenn der Expert Advisor nicht ordnungsgemäß funktioniert. Es wäre nicht schlecht über die Bedingungen Bescheid zu wissen, in denen der Fehler auftritt und ob daraus ein fatales Stocken resultiert. Dies wird funktionieren, wenn die Expert Adviser Logik es ermöglicht Fehler zu erkennen.
• Expert Advisor Betriebszustand. Zum Beispiel wird der EA auf eine Weise eingestellt, dass er jede Stunde eine Nachricht über seinen Betriebszustand sendet, während Sie auf Geschäftsreise sind. Nun könnte es passieren, dass die erwartete Nachricht zur angegebenen Stunde nicht eintrifft. Alles Mögliche könnte passiert sein, von einer Unterbrechung der Internetverbindung, bis zu einem Stromausfall. Wenn das Terminal bei Ihnen zu Hause arbeitet, würde es Sinn machen den Ehepartner zu fragen, den Grund herauszufinden und ihn wieder herzustellen, anstatt vielleicht eine Woche in völliger Unwissenheit zuwarten.

Diese Trennung ist natürlich von einer relativen Natur, und die Liste der möglichen Ereignisse erstreckt sich weit über die in diesem Artikel genannten. Jeder Trader wird für ihn oder sie selbst entscheiden, welchen Inhalt die Nachricht haben sollte. Das Hauptsache ist, zu erkennen, dass diese Funktion sehr hilfreich ist.

Wie Funktioniert Dies mit Skype?

• SMS. Der Service ist, natürlich, kostenpflichtig. Alles sieht aus wie immer: die Nummer des Teilnehmers wählen, die Nachricht schreiben und "Senden&qout; drücken.
• Normale Nachrichten. Dies ist absolut kostenlos. Einfach einen Kontakt auswählen, die Nachricht schreiben und "Senden" drücken.

Wie wird dies aus einem Expert Advisor gemacht?

Ich habe zwei Wege gefunden dies zu machen, und beide benötigen die Verwendung von DLLs:

1. Wir sollten eine Makro-Datei im Voraus vorbereiten, d. h. beim Anstoß dieser Dateikontrolle über Tastatur oder Maus wird abgefangen. So, unter Verwendung der Abfolge von Aktionen, sollten wir Skype aktivieren, das SMS-Senden Element im Menü finden, dann die Teilnehmernummer im erscheinenden Fenster eingeben und aus der Zwischenablage den zunächst im Expert Advisor geschriebenen Text einfügen. So haben wir eine Datei vorbereitet, die ein zugeordnetes Dokument ist und als normale Anwendung gestartet werden kann. Übrigens, es gibt viele Programme die Makro-Dateien aufzeichnen und wiedergeben, also werden wir spezielle Programme in diesem Artikel nicht berücksichtigen.

   Dann müssen wir eine DLL entwickeln, die wie folgt funktioniert. Ihre erste Operation wird das Kopieren von Text aus dem Expert Advisor in die Zwischenablage sein. Die zweite Operation startet die vordefinierte Makro-Datei. Wenn alles eingerichtet ist, und alle Fenster und Schaltflächen an ihrem Platz erscheinen, sollten keine Probleme auftreten und die Nachricht wird gesendet.

   Allerdings ist diese Art und Weise ein wenig beängstigend. Meine Intuition suggeriert mir, dass, wenn der Verstand anfängt so etwas zu erfinden, man eine gefälligere Lösung finden muss, oder die Idee als Ganzes verwerfen. Eine neue Idee blitze in meinen Gedanken auf: Kann Skype eine API besitzen? Nun, ich fand API und ActiveX-Schnittstelle auf deren Webseite. Großartig! Betrachten wir einen anderen Weg, um mit Skype von einem Expert Advisor aus zu arbeiten.

2. Es ist im Wesentlichen das gleiche. Die Nummer des Teilnehmers und der zu sendende Text werden von dem EA an die DLL übergeben, die die Nachricht über das Skype COM-Objekt sendet.

Wie man den Zweiten Weg Realisiert

Lassen Sie uns mit der DLL beginnen. Der Großteil der gesamten Arbeiten wird das Vorbereiten der DLL für die Interaktion mit dem Expert Advisor sein. Zuerst schreiben wir eine Bibliothek, die funktionieren würde, wenn sie von mehreren Expert Advisor aufgerufen wird. Leider wird es nicht ausreichen nur eine Funktion zu schreiben und sie aufzurufen. Wir verwenden ActiveX, also ist es wünschenswert einen spezifisch abgetrennten Thread dafür zu erstellen und die ganze Arbeit in ihm zu machen. Das Standard-Anpassungsinstrument für Mutex-Funktionen wird dabei nicht helfen. Es wird Abstürze geben, die nicht erkannt werden können. Also werden wir die Sequenz der Aufrufe über ein individuelles Messaging-System realisieren.

DLL Quellcode

#include "stdafx.h"
 
#pragma once
// Allow use of features specific to Windows XP or later. 
#ifndef WINVER
// Change this to the appropriate value to target other versions of Windows.
#define WINVER 0x0501      
#endif
// Exclude rarely-used stuff from Windows headers 
#define WIN32_LEAN_AND_MEAN
 
// Include Skype4COM.dll, preliminarily downloaded 
// from the Skype developers website – http://developers.skype.com/
#import "Skype4COM.dll" rename("CreateEvent","CreatePluginEvent"), 
                        rename("SendMessage","SendChatMessage")
 
 
#define MT4_EXPFUNC __declspec(dllexport)
 
// Declare message codes for our functions.
#define WM_PROC_SENDSKYPESMS WM_USER + 01
#define WM_PROC_SENDSKYPEMESSAGE WM_USER + 02
 
// Variables for the thread to be used for 
// sending messages
HANDLE hUserThread;
DWORD ThreadId;
 
// Structures to store parameters of functions
// SendSkypeSMS
struct fcpSendSkypeSMS
  {
    int ExitCode;
    char * UserNum;
    char * Message;
  };
 
// SendSkypeMessage
struct fcpSendSkypeMessage
  {
    int ExitCode;
    char * UserName;
    char * Message;
  };
//+------------------------------------------------------------------+
//| Thread function                                                  |
//+------------------------------------------------------------------+
DWORD WINAPI ThreadProc(LPVOID lpParameter)
  {
    MSG msg;
    HANDLE hEvent;
  
    while(true)
      {
        if(PostThreadMessage(GetCurrentThreadId(), WM_USER, 0, 0))
            break;
      };
    // Initialize COM
    CoInitialize(NULL);
    while(GetMessage(&msg, 0, 0, 0))
      {
        if(msg.message == WM_QUIT)
          {
            break;
          }
        // Message processor WM_PROC_SENDSKYPESMS
        else 
            if(msg.message == WM_PROC_SENDSKYPESMS)
              {
                fcpSendSkypeSMS* fcp = (fcpSendSkypeSMS*)msg.wParam;
                hEvent = (HANDLE)msg.lParam;
                try
                  {
                    // Initialize Skype 
                    SKYPE4COMLib::ISkypePtr pSkype(__uuidof(SKYPE4COMLib::Skype));
                    // Connect to Skype. 6 is the protocol version
                    HRESULT hr=pSkype->Attach(6,VARIANT_TRUE);
                    // If everything is ok, start sending the message
                    if(!FAILED(hr))
                      {    
                        try
                          {
                            fcp->ExitCode = 1;
                            // Try to send an SMS
                            pSkype->SendSms(fcp->UserNum,fcp->Message,"");
                          }
                        catch(...)
                          {
                            fcp->ExitCode=-1;
                          }
                      }
                    // Deinitialize Skype
                    pSkype = NULL;
                  }
                catch(...)
                  {
                    //Error is processed here
                  }
                // Set the event
                SetEvent(hEvent);
              }
            // Message processor WM_PROC_SENDSKYPEMESSAGE
            else 
                if(msg.message == WM_PROC_SENDSKYPEMESSAGE)
                  {
                    fcpSendSkypeMessage* fcp = 
                                   (fcpSendSkypeMessage*)msg.wParam;
                    hEvent = (HANDLE)msg.lParam;
        
                    try
                      {
                        // Initialize Skype 
                        SKYPE4COMLib::ISkypePtr pSkype(__uuidof
                                              (SKYPE4COMLib::Skype));
                        // Connect to Skype. 6 is the protocol version
                        HRESULT hr=pSkype->Attach(6,VARIANT_TRUE);
                        // If everything is ok, start sending the message
                        if(!FAILED(hr))
                          {
                            try
                              {
                                fcp->ExitCode = 1;
                                // Try to send the message
                                pSkype->SendChatMessage(fcp->UserName,
                                                        fcp->Message);
                              }
                            catch(...)
                              {
                                fcp->ExitCode=-1;
                                MessageBeep(0);
                              }
                          }
                        // Deinitialize Skype
                        pSkype = NULL;
                      }
                    catch(...)
                      {
                        //Error is processed here
                      }
  
                    // Set the event
                    SetEvent(hEvent);
                  }
              };
            // Deinitialize COM
            CoUninitialize();
            return 0;
          }
 
//DLL Initialization
//+------------------------------------------------------------------+
//| DLL entry                                                        |
//+------------------------------------------------------------------+
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call,
                      LPVOID lpReserved)
  {
    if(ul_reason_for_call == DLL_PROCESS_ATTACH)
      {
        // Create a thread and attach the processor procedure address to it
        hUserThread = CreateThread(NULL, NULL, ThreadProc, NULL, 0, &ThreadId);
        if(!hUserThread)
          {
            // Error processing if the thread is not created
          };
      } 
    else 
        if(ul_reason_for_call == DLL_PROCESS_DETACH)
          {
            // Delete the thread when exiting the library
            CloseHandle(hUserThread);
          }
    return(TRUE);
  }
 
MT4_EXPFUNC bool __stdcall SendSkypeSMS(int &ExCode,char* sUserNum, 
                                        char* sMessage)
  {
    //Declare the structure of function parameters
    fcpSendSkypeSMS* fcp;
    //Declare an event
    HANDLE hEvent;
    //The result of function operation by default is false
    bool Result = false;
 
    // Allocate a password for the structure and initialize it
    fcp = new fcpSendSkypeSMS();
    memset(fcp, 0, sizeof(fcpSendSkypeSMS));
 
    // Fill out the structure
    //By default, the code of the function working end is an error.
    fcp->ExitCode = -1;
    fcp->UserNum = sUserNum;
    fcp->Message = sMessage;
 
    // Create an event
    hEvent = CreateEvent(NULL,FALSE,FALSE, NULL);
    // Call event WM_PROC_SENDSKYPESMS, pass  the data structure address 
    // to processing procedure 
    PostThreadMessage(ThreadId, WM_PROC_SENDSKYPESMS, (WPARAM)fcp,
                      (LPARAM)hEvent);
    if(WAIT_OBJECT_0 == WaitForSingleObject(hEvent,INFINITE))
      {
        
        Result = true;
      } 
    else
      {
        // If there was an error at message processing, the function will 
        // return false
        return(Result);
      };
    // Assign the function processing code to the variable
    ExCode = fcp->ExitCode;
    if(ExCode == -1) 
        Result = false;
    // Free memory and variables and exit
    delete fcp;
    CloseHandle(hEvent);
    return(Result);
  }
 
MT4_EXPFUNC bool __stdcall SendSkypeMessage(int &ExCode,char* sUserName, 
                                            char* sMessage)
  {
    //Declare the structure of function parameters
 fcpSendSkypeMessage* fcp;
    //Declare an event
    HANDLE hEvent;
    //The result of function operation by default is false
    bool Result = false;
 
    // Allocate memory for the structure and initialize it
    fcp = new fcpSendSkypeMessage();
    memset(fcp, 0, sizeof(fcpSendSkypeMessage));
 
    // Fill out the structure
    //By default, the code of the function working end is an error.
    fcp->ExitCode = -1;
    fcp->UserName = sUserName;
    fcp->Message = sMessage;
 
    // Create an event
    hEvent = CreateEvent(NULL, FALSE,FALSE, NULL);
    // Call the event WM_PROC_SENDSKYPESMS, pass the data structure address 
    // to processing procedure
    PostThreadMessage(ThreadId, WM_PROC_SENDSKYPEMESSAGE, (WPARAM)fcp,
                      (LPARAM)hEvent);
    if(WAIT_OBJECT_0 == WaitForSingleObject(hEvent, INFINITE))
      {
        Result = true;
      } 
    else
      {
        // If there was an error at message processing, the function will 
        // return false
        return(Result);
      };
    // Assign the function processing code to the variable
    ExCode = fcp->ExitCode;
    if(ExCode == -1) 
        Result = false;
    // Free memory and variables and exit
    delete fcp;
    CloseHandle(hEvent);
    return(Result);
  }

Datei DEF

LIBRARY SkypeLib
 
EXPORTS SendSkypeSMS
        SendSkypeMessage

Zu Testender Expert Advisor

//+------------------------------------------------------------------+
//|                                              SkypeTestExpert.mq4 |
//|                               Copyright © 2007, Alexey Koshevoy. |
//+------------------------------------------------------------------+
// Import functions
#import "SkypeLib.dll"
   bool SendSkypeSMS(int &ExCode[], string Num,string Message);
   bool SendSkypeMessage(int &ExCode[], string User, string Message);
#import
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
   int ExCode[1];
   Alert("Send message...");
   Alert(SendSkypeMessage(ExCode, "skype.account.name", "Skype message test"));
   if(ExCode[0] == -1)
       Alert("Error sending the message");
   else 
       Alert("Message sent");
   Alert("Send SMS...");
   Alert(SendSkypeSMS(ExCode, "[phone]", "Skype sms test"));
   if(ExCode[0] == -1)
       Alert("Error sending the SMS");
   else
       Alert("SMS sent");
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   return(0);
  }
//+------------------------------------------------------------------+

Der EA ist sehr einfach. Sein Hauptziel ist es, eine SMS und eine regelmäßige Nachricht über die DLL zu senden, die wir geschrieben haben. Er agiert in der Initialisierungsfunktion, also kann er auch an Wochenenden getestet werden.

Skype Installation

Die Anwendung kann auf http://www.skype.com/ heruntergeladen werden. Es ist empfehlenswert die neueste Version des Programm zu installieren, da die vorhergehenden Versionen keine COM-Schnittstelle unterstützen. Sie haben nur eine API. Allerdings unterstützt API nicht das Senden von SMS.

Nun, Skype wurde bereits installiert. Jetzt müssen wir die COM-Bibliothek herunterladen. Sie ist unter https://developer.skype.com/ unter Downloads zu finden. Prüfen Sie das Guthaben im Konto, für das Versenden von SMS. Es ist nicht möglich SMS ohne Guthaben auf dem Konto zu versenden, aber normale Nachrichten können ohne Probleme versendet werden.

Für den Terminal-Zugriff auf Skype API, muss es registriert werden. Sie können prüfen unter Tools->Options->Privacy->Manage other programs access to Skype prüfen, ob es erlaubt ist mit API zu arbeiten. Es muss ungefähr so aussehen:

Das Terminal wird beidem ersten Versuch die Bibliothek zu verwenden registriert. Es kann nicht manuell gemacht werden. Wenn also die Bibliothek zu ersten Mal installiert ist, ist es notwendig zu warten bis eine Nachricht versendet wurde, um die Berechtigung für die Verwendung von Skype-API bestätigt zu haben. Skype wird das folgende Dialogfeld anzeigen:

Nach der Bestätigung wird das System anfangen im automatischen Modus zu arbeiten.

Installation von SkypeLib

Um die Bibliothek mit dem Namen SkypeLib.dll zu installieren, ist es notwendig sie in den Ordner experts/libaries im Terminal-Verzeichnis zu kopieren. Die Bibliothek mit dem Namen Skype4COM.,dll muss ebenfalls in diesen Ordner kopiert werden. Nun müssen wir das Terminal einstellen, damit es in der Lage ist mit den DLL zu arbeiten. Dafür setzen wir ein Häkchen im Feld "Import von DLLs zulassen" im Bereich "Sicherheit", wenn wir einen EA wie unten dargestellt anhängen:

Jetzt können wir die Bibliothek verwenden.

Einige Wichtige Einzelheiten

Mit etwas Erfahrung in Testen und Implementierung, bemerkte ich einige "Feinheiten". Zum Beispiel müssen Sie berücksichtigen, dass, wenn Sie genug Geld auf dem Konto haben und eine SMS an eine nicht existierende Nummer senden, die Funktion erfolgreich arbeiten wird, während der Nachrichtenstatus auf "sende..." gesetzt wird. Deshalb ist es wichtig die Funktionen sehr deutlich einzurichten. Es ist außerdem sehr wichtig die Skype-Version 3.0 (oder spätere Versionen) zu verwenden.

Es kommt vor (aber eher selten), dass COM-Objekt nicht initialisiert ist und keine Nachrichten gesendet werden. Dies kann nur mit einer Neuinstallation von Skype behoben werden. Die externe Schnittstelle ist relativ neu, nicht ohne Fehler, also können unangenehme Dinge auftreten. Es ist nach meinem Wissen zweimal geschehen. Lassen Sie uns hoffen, dass spätere Versionen stabiler arbeiten werden.

Es muss auch darauf hingewiesen werden, dass einige zusätzliche Bibliotheken für das Funktionieren der SkypeLib.dll benötigt werden können. Das Problem ist besonders akut, nachdem das erste Service-Pack für Visual Studio 2005 veröffentlicht wurde. Der beste Weg dieses Problem zu lösen, ist es eine Setup-Datei zu erstellen. Alle benötigten Bibliotheken werden automatisch in dieser aufgenommen werden. Die Datei Skype4COM.dll kann ebenfalls in sie eingeschlossen werden.

An den Artikel angehängte Dateien

• SkypeLib.dll - Die Bibliothek wurde in Visual C++ 6.0 kompiliert. Sie benötigt keine zusätzlichen Dateien, aber Skype4COM.dll.
• SkypeLib.zip - Der Bibliothek-Quellcode.
• SkypeExample.mq4 - Ein Expert Advisor um die Bibliothek zu testen.

Hochs und Tiefs

Die folgenden Nachteile sind bei der Verwendung von Skype-SMS zu beachten:

• SMS kosten etwas Geld
• Man kann keine Nachrichten an sich selbst senden. Es ist notwendig ein weiteres Skype-Konto zu haben, um Nachrichten zu empfangen.
• Ihr Telefon muss die mobile Version von Skype unterstützen. Wenn ein Computer für den Empfang von Nachrichten verwendet wird, entfällt dieser Nachteil.

Diese Methode hat die folgenden Vorteile:

• Signale im Echtzeit-Modus
• Funktion die zurzeit durch nichts anderes ersetzt werden kann. Das ist nicht einmal ein Vorteil, es ist einfach eine Tatsache.

Fazit

Wir haben erfahren, wie man SMS und regelmäßige Nachrichten über Skype verschickt. Auf diese Weise haben wir eine Schnittstelle erhalten, die vielleicht nicht die bequemste ist, aber unverzichtbar, um uns über aktuelle Ereignisse im Terminal zu informieren. Was kommt als nächstes? Nun, zum Beispiel, Skype ermöglicht beides, Senden und EMPFANGEN von Nachrichten...