mirror
/
ESP32-CAM-Video-Telegram
kopia lustrzana https://github.com/jameszah/ESP32-CAM-Video-Telegram
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

ver 9.6 -- Oct 22, 2022 

add wifimanager option to choose HD or VGA
main
jameszah 2022-10-22 22:52:51 -06:00 zatwierdzone przez GitHub
rodzic 2527976116
commit a79d68df6e
Nie znaleziono w bazie danych klucza dla tego podpisu
ID klucza GPG: 4AEE18F83AFDEB23
3 zmienionych plików z 2722 dodań i 0 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

1605
v9.6/ESP32-CAM-Video-Telegram_9.6/ESP32-CAM-Video-Telegram_9.6.ino 100644
Wyświetl plik

File diff suppressed because one or more lines are too long

963
v9.6/ESP32-CAM-Video-Telegram_9.6/UniversalTelegramBot.cpp 100644
Wyświetl plik

@ -0,0 +1,963 @@
/*
Copyright (c) 2018 Brian Lough. All right reserved.
UniversalTelegramBot - Library to create your own Telegram Bot using
ESP8266 or ESP32 on Arduino IDE.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
**** Note Regarding Client Connection Keeping ****
Client connection is established in functions that directly involve use of
client, i.e sendGetToTelegram, sendPostToTelegram, and
sendMultipartFormDataToTelegram. It is closed at the end of
sendMultipartFormDataToTelegram, but not at the end of sendGetToTelegram and
sendPostToTelegram as these may need to keep the connection alive for respose
/ response checking. Re-establishing a connection then wastes time which is
noticeable in user experience. Due to this, it is important that connection
be closed manually after calling sendGetToTelegram or sendPostToTelegram by
calling closeClient(); Failure to close connection causes memory leakage and
SSL errors
*/
#include "UniversalTelegramBot.h"
#define ZERO_COPY(STR) ((char*)STR.c_str())
#define BOT_CMD(STR) buildCommand(F(STR))
UniversalTelegramBot::UniversalTelegramBot(const String& token, Client &client) {
updateToken(token);
this->client = &client;
}
void UniversalTelegramBot::updateToken(const String& token) {
_token = token;
}
String UniversalTelegramBot::getToken() {
return _token;
}
String UniversalTelegramBot::buildCommand(const String& cmd) {
String command;
command += F("bot");
command += _token;
command += F("/");
command += cmd;
return command;
}
String UniversalTelegramBot::sendGetToTelegram(const String& command) {
String body, headers;
bool avail;
// Connect with api.telegram.org if not already connected
if (!client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT]Connecting to server"));
#endif
if (!client->connect(TELEGRAM_HOST, TELEGRAM_SSL_PORT)) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT]Conection error"));
#endif
}
}
if (client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println("sending: " + command);
#endif
client->print(F("GET /"));
client->print(command);
client->println(F(" HTTP/1.1"));
client->println(F("Host:" TELEGRAM_HOST));
client->println(F("Accept: application/json"));
client->println(F("Cache-Control: no-cache"));
client->println();
readHTTPAnswer(body, headers);
}
return body;
}
bool UniversalTelegramBot::readHTTPAnswer(String &body, String &headers) {
int ch_count = 0;
long now = millis();
bool finishedHeaders = false;
bool currentLineIsBlank = true;
bool responseReceived = false;
while (millis() - now < longPoll * 1000 + waitForResponse) {
while (client->available()) {
char c = client->read();
responseReceived = true;
if (!finishedHeaders) {
if (currentLineIsBlank && c == '\n') {
finishedHeaders = true;
} else {
headers += c;
}
} else {
if (ch_count < maxMessageLength) {
body += c;
ch_count++;
}
}
if (c == '\n') currentLineIsBlank = true;
else if (c != '\r') currentLineIsBlank = false;
}
if (responseReceived && ch_count > 5) { //jz
#ifdef TELEGRAM_DEBUG
Serial.print(">");
Serial.print(body);
Serial.println("<");
#endif
break;
}
}
return responseReceived;
}
String UniversalTelegramBot::sendPostToTelegram(const String& command, JsonObject payload) {
String body;
String headers;
// Connect with api.telegram.org if not already connected
if (!client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Connecting to server"));
#endif
if (!client->connect(TELEGRAM_HOST, TELEGRAM_SSL_PORT)) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Conection error"));
#endif
}
}
if (client->connected()) {
// POST URI
client->print(F("POST /"));
client->print(command);
client->println(F(" HTTP/1.1"));
// Host header
client->println(F("Host:" TELEGRAM_HOST));
// JSON content type
client->println(F("Content-Type: application/json"));
// Content length
int length = measureJson(payload);
client->print(F("Content-Length:"));
client->println(length);
// End of headers
client->println();
// POST message body
String out;
serializeJson(payload, out);
client->println(out);
#ifdef TELEGRAM_DEBUG
Serial.println(String("Posting:") + out);
#endif
readHTTPAnswer(body, headers);
}
return body;
}
String UniversalTelegramBot::sendMultipartFormDataToTelegram(
const String& command, const String& binaryPropertyName, const String& fileName,
const String& contentType, const String& chat_id, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback,
GetNextBuffer getNextBufferCallback,
GetNextBufferLen getNextBufferLenCallback) {
String body;
String headers;
const String boundary = F("------------------------b8f610217e83e29b");
// Connect with api.telegram.org if not already connected
if (!client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Connecting to server"));
#endif
if (!client->connect(TELEGRAM_HOST, TELEGRAM_SSL_PORT)) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Conection error"));
#endif
}
}
if (client->connected()) {
String start_request = "";
String end_request = "";
start_request += F("--");
start_request += boundary;
start_request += F("\r\ncontent-disposition: form-data; name=\"chat_id\"\r\n\r\n");
start_request += chat_id;
start_request += F("\r\n" "--");
start_request += boundary;
start_request += F("\r\ncontent-disposition: form-data; name=\"");
start_request += binaryPropertyName;
start_request += F("\"; filename=\"");
start_request += fileName;
start_request += F("\"\r\n" "Content-Type: ");
start_request += contentType;
start_request += F("\r\n" "\r\n");
end_request += F("\r\n" "--");
end_request += boundary;
end_request += F("--" "\r\n");
client->print(F("POST /"));
client->print(buildCommand(command));
client->println(F(" HTTP/1.1"));
Serial.print("*") ; delay(jzdelay);
// Host header
client->println(F("Host: " TELEGRAM_HOST)); //jz <<<<<<<<<<<<<<<<<<<<< println !!!!!!!! >>>>>>>>>>>>>>>>>>>>
client->println(F("User-Agent: arduino/1.0"));
Serial.print("*") ; delay(jzdelay);
client->println(F("Accept: */*"));
Serial.print("*") ; delay(jzdelay);
int contentLength = fileSize + start_request.length() + end_request.length();
#ifdef TELEGRAM_DEBUG
Serial.println("Content-Length: " + String(contentLength));
#endif
client->print(F("Content-Length: "));
client->println(String(contentLength));
Serial.print("*") ; delay(jzdelay);
client->print(F("Content-Type: multipart/form-data; boundary="));
client->println(boundary);
//Serial.print(" --- bef ---") ; delay(jzdelay);
client->println(); // client->println(F"");
//Serial.print(" --- aft ---") ; delay(jzdelay);
client->print(start_request);
Serial.print("*") ; delay(jzdelay);
#ifdef TELEGRAM_DEBUG
Serial.print("Start request: " + start_request);
#endif
if (getNextByteCallback == nullptr) {
while (moreDataAvailableCallback()) {
client->write((const uint8_t *)getNextBufferCallback(), getNextBufferLenCallback());
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending photo from buffer"));
#endif
}
} else {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending photo by binary"));
#endif
//byte buffer[jzblocksize];
int count = 0;
char ch;
while (moreDataAvailableCallback()) {
buffer[count] = getNextByteCallback();
count++;
if (count == jzblocksize) {
// yield();
#ifdef TELEGRAM_DEBUG
//jz Serial.println(F("Sending binary photo full buffer"));
#endif
client->write((const uint8_t *)buffer, jzblocksize);
Serial.print("*") ; delay(jzdelay);
count = 0;
}
}
if (count > 0) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending binary photo remaining buffer"));
#endif
client->write((const uint8_t *)buffer, count);
Serial.print("*") ; delay(jzdelay);
}
}
client->print(end_request);
Serial.print("*") ; delay(jzdelay);
#ifdef TELEGRAM_DEBUG
Serial.print("End request: " + end_request);
#endif
//Serial.print("... Done Sending. Client.Available = "); Serial.println(client->available());
//delay(2000);
//Serial.print("... 2 secs later. Client.Available = "); Serial.println(client->available());
readHTTPAnswer(body, headers);
}
closeClient();
return body;
}
String UniversalTelegramBot::sendMultipartFormDataToTelegramWithCaption(
const String& command, const String& binaryPropertyName, const String& fileName,
const String& contentType, const String& caption, const String& chat_id, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback,
GetNextBuffer getNextBufferCallback,
GetNextBufferLen getNextBufferLenCallback) {
String body;
String headers;
const String boundary = F("------------------------b8f610217e83e29b");
// Connect with api.telegram.org if not already connected
if (!client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Connecting to server"));
#endif
if (!client->connect(TELEGRAM_HOST, TELEGRAM_SSL_PORT)) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("[BOT Client]Conection error"));
#endif
}
}
if (client->connected()) {
String start_request = "";
String end_request = "";
start_request += F("--");
start_request += boundary;
start_request += F("\r\ncontent-disposition: form-data; name=\"chat_id\"\r\n\r\n");
start_request += chat_id;
start_request += F("\r\n" "--");
// jz caption start
start_request += boundary;
start_request += F("\r\ncontent-disposition: form-data; name=\"caption\"\r\n\r\n");
start_request += caption;
start_request += F("\r\n" "--");
// jz caption end
start_request += boundary;
start_request += F("\r\ncontent-disposition: form-data; name=\"");
start_request += binaryPropertyName;
start_request += F("\"; filename=\"");
start_request += fileName;
start_request += F("\"\r\n" "Content-Type: ");
start_request += contentType;
start_request += F("\r\n" "\r\n");
end_request += F("\r\n" "--");
end_request += boundary;
end_request += F("--" "\r\n");
client->print(F("POST /"));
client->print(buildCommand(command));
client->println(F(" HTTP/1.1"));
Serial.print("*") ; delay(jzdelay);
// Host header
client->println(F("Host: " TELEGRAM_HOST)); //jz <<<<<<<<<<<<<<<<<<<<< println !!!!!!!! >>>>>>>>>>>>>>>>>>>>
client->println(F("User-Agent: arduino/1.0"));
Serial.print("*") ; delay(jzdelay);
client->println(F("Accept: */*"));
Serial.print("*") ; delay(jzdelay);
int contentLength = fileSize + start_request.length() + end_request.length();
#ifdef TELEGRAM_DEBUG
Serial.println("Content-Length: " + String(contentLength));
#endif
client->print(F("Content-Length: "));
client->println(String(contentLength));
Serial.print("*") ; delay(jzdelay);
client->print(F("Content-Type: multipart/form-data; boundary="));
client->println(boundary);
Serial.print("*") ; delay(jzdelay);
client->println(); // client->println(F("")); <--- jz 1.05 bug
Serial.print("*") ; delay(jzdelay);
client->print(start_request);
Serial.print("*") ; delay(jzdelay);
#ifdef TELEGRAM_DEBUG
Serial.print("Start request: " + start_request);
#endif
if (getNextByteCallback == nullptr) {
while (moreDataAvailableCallback()) {
client->write((const uint8_t *)getNextBufferCallback(), getNextBufferLenCallback());
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending photo from buffer"));
#endif
}
} else {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending photo by binary"));
#endif
//byte buffer[jzblocksize];
int count = 0;
char ch;
while (moreDataAvailableCallback()) {
buffer[count] = getNextByteCallback();
count++;
if (count == jzblocksize) {
// yield();
#ifdef TELEGRAM_DEBUG
//jz Serial.println(F("Sending binary photo full buffer"));
#endif
client->write((const uint8_t *)buffer, jzblocksize);
Serial.print("*") ; delay(jzdelay);
count = 0;
}
}
if (count > 0) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Sending binary photo remaining buffer"));
#endif
client->write((const uint8_t *)buffer, count);
Serial.print("*") ; delay(jzdelay);
}
}
client->print(end_request);
Serial.print("*") ; delay(jzdelay);
#ifdef TELEGRAM_DEBUG
Serial.print("End request: " + end_request);
#endif
//Serial.print("... Done Sending. Client.Available = "); Serial.println(client->available());
//delay(2000);
//Serial.print("... 2 secs later. Client.Available = "); Serial.println(client->available());
readHTTPAnswer(body, headers);
}
closeClient();
return body;
}
bool UniversalTelegramBot::getMe() {
String response = sendGetToTelegram(BOT_CMD("getMe")); // receive reply from telegram.org
DynamicJsonDocument doc(maxMessageLength);
DeserializationError error = deserializeJson(doc, ZERO_COPY(response));
closeClient();
if (!error) {
if (doc.containsKey("result")) {
name = doc["result"]["first_name"].as<String>();
userName = doc["result"]["username"].as<String>();
return true;
}
}
return false;
}
/*********************************************************************************
* SetMyCommands - Update the command list of the bot on the telegram server *
* (Argument to pass: Serialied array of BotCommand) *
* CAUTION: All commands must be lower-case *
* Returns true, if the command list was updated successfully *
********************************************************************************/
bool UniversalTelegramBot::setMyCommands(const String& commandArray) {
DynamicJsonDocument payload(maxMessageLength);
payload["commands"] = serialized(commandArray);
bool sent = false;
String response = "";
#if defined(_debug)
Serial.println(F("sendSetMyCommands: SEND Post /setMyCommands"));
#endif // defined(_debug)
unsigned long sttime = millis();
while (millis() < sttime + 8000ul) { // loop for a while to send the message
response = sendPostToTelegram(BOT_CMD("setMyCommands"), payload.as<JsonObject>());
#ifdef _debug
Serial.println("setMyCommands response" + response);
#endif
sent = checkForOkResponse(response);
if (sent) break;
}
closeClient();
return sent;
}
/***************************************************************
* GetUpdates - function to receive messages from telegram *
* (Argument to pass: the last+1 message to read) *
* Returns the number of new messages *
***************************************************************/
int UniversalTelegramBot::getUpdates(long offset) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("GET Update Messages"));
#endif
String command = BOT_CMD("getUpdates?offset=");
command += offset;
command += F("&limit=");
command += HANDLE_MESSAGES;
if (longPoll > 0) {
command += F("&timeout=");
command += String(longPoll);
}
String response = sendGetToTelegram(command); // receive reply from telegram.org
if (response == "") {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Received empty string in response!"));
#endif
// close the client as there's nothing to do with an empty string
closeClient();
return 0;
} else {
#ifdef TELEGRAM_DEBUG
Serial.print(F("incoming message length "));
Serial.println(response.length());
Serial.println(F("Creating DynamicJsonBuffer"));
#endif
// Parse response into Json object
DynamicJsonDocument doc(maxMessageLength);
DeserializationError error = deserializeJson(doc, ZERO_COPY(response));
if (!error) {
#ifdef TELEGRAM_DEBUG
Serial.print(F("GetUpdates parsed jsonObj: "));
serializeJson(doc, Serial);
Serial.println();
#endif
if (doc.containsKey("result")) {
int resultArrayLength = doc["result"].size();
if (resultArrayLength > 0) {
int newMessageIndex = 0;
// Step through all results
for (int i = 0; i < resultArrayLength; i++) {
JsonObject result = doc["result"][i];
if (processResult(result, newMessageIndex)) newMessageIndex++;
}
// We will keep the client open because there may be a response to be
// given
return newMessageIndex;
} else {
#ifdef TELEGRAM_DEBUG
Serial.println(F("no new messages"));
#endif
}
} else {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Response contained no 'result'"));
#endif
}
} else { // Parsing failed
if (response.length() < 2) { // Too short a message. Maybe a connection issue
#ifdef TELEGRAM_DEBUG
Serial.println(F("Parsing error: Message too short"));
#endif
} else {
// Buffer may not be big enough, increase buffer or reduce max number of
// messages
#ifdef TELEGRAM_DEBUG
Serial.print(F("Failed to parse update, the message could be too "
"big for the buffer. Error code: "));
Serial.println(error.c_str()); // debug print of parsing error
#endif
}
}
// Close the client as no response is to be given
closeClient();
return 0;
}
}
bool UniversalTelegramBot::processResult(JsonObject result, int messageIndex) {
int update_id = result["update_id"];
// Check have we already dealt with this message (this shouldn't happen!)
if (last_message_received != update_id) {
last_message_received = update_id;
messages[messageIndex].update_id = update_id;
messages[messageIndex].text = F("");
messages[messageIndex].from_id = F("");
messages[messageIndex].from_name = F("");
messages[messageIndex].longitude = 0;
messages[messageIndex].latitude = 0;
messages[messageIndex].reply_to_message_id = 0;
messages[messageIndex].reply_to_text = F("");
messages[messageIndex].query_id = F("");
if (result.containsKey("message")) {
JsonObject message = result["message"];
messages[messageIndex].type = F("message");
messages[messageIndex].from_id = message["from"]["id"].as<String>();
messages[messageIndex].from_name = message["from"]["first_name"].as<String>();
messages[messageIndex].date = message["date"].as<String>();
messages[messageIndex].chat_id = message["chat"]["id"].as<String>();
messages[messageIndex].chat_title = message["chat"]["title"].as<String>();
messages[messageIndex].hasDocument = false;
if (message.containsKey("text")) {
messages[messageIndex].text = message["text"].as<String>();
} else if (message.containsKey("location")) {
messages[messageIndex].longitude = message["location"]["longitude"].as<float>();
messages[messageIndex].latitude = message["location"]["latitude"].as<float>();
} else if (message.containsKey("document")) {
String file_id = message["document"]["file_id"].as<String>();
messages[messageIndex].file_caption = message["caption"].as<String>();
messages[messageIndex].file_name = message["document"]["file_name"].as<String>();
if (getFile(messages[messageIndex].file_path, messages[messageIndex].file_size, file_id) == true)
messages[messageIndex].hasDocument = true;
else
messages[messageIndex].hasDocument = false;
}
if (message.containsKey("reply_to_message")) {
messages[messageIndex].reply_to_message_id = message["reply_to_message"]["message_id"];
// no need to check if containsKey["text"]. If it doesn't, it default to null
messages[messageIndex].reply_to_text = message["reply_to_message"]["text"].as<String>();
}
} else if (result.containsKey("channel_post")) {
JsonObject message = result["channel_post"];
messages[messageIndex].type = F("channel_post");
messages[messageIndex].text = message["text"].as<String>();
messages[messageIndex].date = message["date"].as<String>();
messages[messageIndex].chat_id = message["chat"]["id"].as<String>();
messages[messageIndex].chat_title = message["chat"]["title"].as<String>();
} else if (result.containsKey("callback_query")) {
JsonObject message = result["callback_query"];
messages[messageIndex].type = F("callback_query");
messages[messageIndex].from_id = message["from"]["id"].as<String>();
messages[messageIndex].from_name = message["from"]["first_name"].as<String>();
messages[messageIndex].text = message["data"].as<String>();
messages[messageIndex].date = message["date"].as<String>();
messages[messageIndex].chat_id = message["message"]["chat"]["id"].as<String>();
messages[messageIndex].reply_to_text = message["message"]["text"].as<String>();
messages[messageIndex].chat_title = F("");
messages[messageIndex].query_id = message["id"].as<String>();
} else if (result.containsKey("edited_message")) {
JsonObject message = result["edited_message"];
messages[messageIndex].type = F("edited_message");
messages[messageIndex].from_id = message["from"]["id"].as<String>();
messages[messageIndex].from_name = message["from"]["first_name"].as<String>();
messages[messageIndex].date = message["date"].as<String>();
messages[messageIndex].chat_id = message["chat"]["id"].as<String>();
messages[messageIndex].chat_title = message["chat"]["title"].as<String>();
if (message.containsKey("text")) {
messages[messageIndex].text = message["text"].as<String>();
} else if (message.containsKey("location")) {
messages[messageIndex].longitude = message["location"]["longitude"].as<float>();
messages[messageIndex].latitude = message["location"]["latitude"].as<float>();
}
}
return true;
}
return false;
}
/***********************************************************************
* SendMessage - function to send message to telegram *
* (Arguments to pass: chat_id, text to transmit and markup(optional)) *
***********************************************************************/
bool UniversalTelegramBot::sendSimpleMessage(const String& chat_id, const String& text,
const String& parse_mode) {
bool sent = false;
#ifdef TELEGRAM_DEBUG
Serial.println(F("sendSimpleMessage: SEND Simple Message"));
#endif
long sttime = millis();
if (text != "") {
while (millis() < sttime + 8000) { // loop for a while to send the message
String command = BOT_CMD("sendMessage?chat_id=");
command += chat_id;
command += F("&text=");
command += text;
command += F("&parse_mode=");
command += parse_mode;
String response = sendGetToTelegram(command);
#ifdef TELEGRAM_DEBUG
Serial.println(response);
#endif
sent = checkForOkResponse(response);
if (sent) break;
}
}
closeClient();
return sent;
}
bool UniversalTelegramBot::sendMessage(const String& chat_id, const String& text,
const String& parse_mode) {
DynamicJsonDocument payload(maxMessageLength);
payload["chat_id"] = chat_id;
payload["text"] = text;
if (parse_mode != "")
payload["parse_mode"] = parse_mode;
return sendPostMessage(payload.as<JsonObject>());
}
bool UniversalTelegramBot::sendMessageWithReplyKeyboard(
const String& chat_id, const String& text, const String& parse_mode, const String& keyboard,
bool resize, bool oneTime, bool selective) {
DynamicJsonDocument payload(maxMessageLength);
payload["chat_id"] = chat_id;
payload["text"] = text;
if (parse_mode != "")
payload["parse_mode"] = parse_mode;
JsonObject replyMarkup = payload.createNestedObject("reply_markup");
replyMarkup["keyboard"] = serialized(keyboard);
// Telegram defaults these values to false, so to decrease the size of the
// payload we will only send them if needed
if (resize)
replyMarkup["resize_keyboard"] = resize;
if (oneTime)
replyMarkup["one_time_keyboard"] = oneTime;
if (selective)
replyMarkup["selective"] = selective;
return sendPostMessage(payload.as<JsonObject>());
}
bool UniversalTelegramBot::sendMessageWithInlineKeyboard(const String& chat_id,
const String& text,
const String& parse_mode,
const String& keyboard) {
DynamicJsonDocument payload(maxMessageLength);
payload["chat_id"] = chat_id;
payload["text"] = text;
if (parse_mode != "")
payload["parse_mode"] = parse_mode;
JsonObject replyMarkup = payload.createNestedObject("reply_markup");
replyMarkup["inline_keyboard"] = serialized(keyboard);
return sendPostMessage(payload.as<JsonObject>());
}
/***********************************************************************
* SendPostMessage - function to send message to telegram *
* (Arguments to pass: chat_id, text to transmit and markup(optional)) *
***********************************************************************/
bool UniversalTelegramBot::sendPostMessage(JsonObject payload) {
bool sent = false;
#ifdef TELEGRAM_DEBUG
Serial.print(F("sendPostMessage: SEND Post Message: "));
serializeJson(payload, Serial);
Serial.println();
#endif
long sttime = millis();
if (payload.containsKey("text")) {
while (millis() < sttime + 8000) { // loop for a while to send the message
String response = sendPostToTelegram(BOT_CMD("sendMessage"), payload);
#ifdef TELEGRAM_DEBUG
Serial.println(response);
#endif
sent = checkForOkResponse(response);
if (sent) break;
}
}
closeClient();
return sent;
}
String UniversalTelegramBot::sendPostPhoto(JsonObject payload) {
bool sent = false;
String response = "";
#ifdef TELEGRAM_DEBUG
Serial.println(F("sendPostPhoto: SEND Post Photo"));
#endif
long sttime = millis();
if (payload.containsKey("photo")) {
while (millis() < sttime + 8000) { // loop for a while to send the message
response = sendPostToTelegram(BOT_CMD("sendPhoto"), payload);
#ifdef TELEGRAM_DEBUG
Serial.println(response);
#endif
sent = checkForOkResponse(response);
if (sent) break;
}
}
closeClient();
return response;
}
String UniversalTelegramBot::sendPhotoByBinary(
const String& chat_id, const String& contentType, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback, GetNextBuffer getNextBufferCallback, GetNextBufferLen getNextBufferLenCallback) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("sendPhotoByBinary: SEND Photo"));
#endif
String response = sendMultipartFormDataToTelegram("sendPhoto", "photo", "img.jpg",
contentType, chat_id, fileSize,
moreDataAvailableCallback, getNextByteCallback, getNextBufferCallback, getNextBufferLenCallback);
#ifdef TELEGRAM_DEBUG
Serial.println(response);
#endif
return response;
}
String UniversalTelegramBot::sendPhoto(const String& chat_id, const String& photo,
const String& caption,
bool disable_notification,
int reply_to_message_id,
const String& keyboard) {
DynamicJsonDocument payload(maxMessageLength);
payload["chat_id"] = chat_id;
payload["photo"] = photo;
if (caption.length() > 0)
payload["caption"] = caption;
if (disable_notification)
payload["disable_notification"] = disable_notification;
if (reply_to_message_id && reply_to_message_id != 0)
payload["reply_to_message_id"] = reply_to_message_id;
if (keyboard.length() > 0) {
JsonObject replyMarkup = payload.createNestedObject("reply_markup");
replyMarkup["keyboard"] = serialized(keyboard);
}
return sendPostPhoto(payload.as<JsonObject>());
}
bool UniversalTelegramBot::checkForOkResponse(const String& response) {
int last_id;
DynamicJsonDocument doc(response.length());
deserializeJson(doc, response);
// Save last sent message_id
last_id = doc["result"]["message_id"];
if (last_id > 0) last_sent_message_id = last_id;
return doc["ok"] | false; // default is false, but this is more explicit and clear
}
bool UniversalTelegramBot::sendChatAction(const String& chat_id, const String& text) {
bool sent = false;
#ifdef TELEGRAM_DEBUG
Serial.println(F("SEND Chat Action Message"));
#endif
long sttime = millis();
if (text != "") {
while (millis() < sttime + 8000) { // loop for a while to send the message
String command = BOT_CMD("sendChatAction?chat_id=");
command += chat_id;
command += F("&action=");
command += text;
String response = sendGetToTelegram(command);
#ifdef TELEGRAM_DEBUG
Serial.println(response);
#endif
sent = checkForOkResponse(response);
if (sent) break;
}
}
closeClient();
return sent;
}
void UniversalTelegramBot::closeClient() {
if (client->connected()) {
#ifdef TELEGRAM_DEBUG
Serial.println(F("Closing client"));
#endif
client->stop();
}
}
bool UniversalTelegramBot::getFile(String& file_path, long& file_size, const String& file_id)
{
String command = BOT_CMD("getFile?file_id=");
command += file_id;
String response = sendGetToTelegram(command); // receive reply from telegram.org
DynamicJsonDocument doc(maxMessageLength);
DeserializationError error = deserializeJson(doc, ZERO_COPY(response));
closeClient();
if (!error) {
if (doc.containsKey("result")) {
file_path = F("https://api.telegram.org/file/");
file_path += buildCommand(doc["result"]["file_path"]);
file_size = doc["result"]["file_size"].as<long>();
return true;
}
}
return false;
}
bool UniversalTelegramBot::answerCallbackQuery(const String &query_id, const String &text, bool show_alert, const String &url, int cache_time) {
DynamicJsonDocument payload(maxMessageLength);
payload["callback_query_id"] = query_id;
payload["show_alert"] = show_alert;
payload["cache_time"] = cache_time;
if (text.length() > 0) payload["text"] = text;
if (url.length() > 0) payload["url"] = url;
String response = sendPostToTelegram(BOT_CMD("answerCallbackQuery"), payload.as<JsonObject>());
#ifdef _debug
Serial.print(F("answerCallbackQuery response:"));
Serial.println(response);
#endif
bool answer = checkForOkResponse(response);
closeClient();
return answer;
}

154
v9.6/ESP32-CAM-Video-Telegram_9.6/UniversalTelegramBot.h 100644
Wyświetl plik

@ -0,0 +1,154 @@
/*
Copyright (c) 2018 Brian Lough. All right reserved.
UniversalTelegramBot - Library to create your own Telegram Bot using
ESP8266 or ESP32 on Arduino IDE.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef UniversalTelegramBot_h
#define UniversalTelegramBot_h
//#define TELEGRAM_DEBUG 0 //jz
#define ARDUINOJSON_DECODE_UNICODE 1
#define ARDUINOJSON_USE_LONG_LONG 1
#include <Arduino.h>
#include <ArduinoJson.h>
#include <Client.h>
#define TELEGRAM_HOST "api.telegram.org"
#define TELEGRAM_SSL_PORT 443
#define HANDLE_MESSAGES 1
//unmark following line to enable debug mode
//#define _debug
typedef bool (*MoreDataAvailable)();
typedef byte (*GetNextByte)();
typedef byte* (*GetNextBuffer)();
typedef int (GetNextBufferLen)();
struct telegramMessage {
String text;
String chat_id;
String chat_title;
String from_id;
String from_name;
String date;
String type;
String file_caption;
String file_path;
String file_name;
bool hasDocument;
long file_size;
float longitude;
float latitude;
int update_id;
int reply_to_message_id;
String reply_to_text;
String query_id;
};
class UniversalTelegramBot {
public:
UniversalTelegramBot(const String& token, Client &client);
void updateToken(const String& token);
String getToken();
String sendGetToTelegram(const String& command);
String sendPostToTelegram(const String& command, JsonObject payload);
String
sendMultipartFormDataToTelegram(const String& command, const String& binaryPropertyName,
const String& fileName, const String& contentType,
const String& chat_id, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback,
GetNextBuffer getNextBufferCallback,
GetNextBufferLen getNextBufferLenCallback);
//jz caption
String
sendMultipartFormDataToTelegramWithCaption(const String& command, const String& binaryPropertyName,
const String& fileName, const String& contentType,
const String& caption,
const String& chat_id, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback,
GetNextBuffer getNextBufferCallback,
GetNextBufferLen getNextBufferLenCallback);
bool readHTTPAnswer(String &body, String &headers);
bool getMe();
bool sendSimpleMessage(const String& chat_id, const String& text, const String& parse_mode);
bool sendMessage(const String& chat_id, const String& text, const String& parse_mode = "");
bool sendMessageWithReplyKeyboard(const String& chat_id, const String& text,
const String& parse_mode, const String& keyboard,
bool resize = false, bool oneTime = false,
bool selective = false);
bool sendMessageWithInlineKeyboard(const String& chat_id, const String& text,
const String& parse_mode, const String& keyboard);
bool sendChatAction(const String& chat_id, const String& text);
bool sendPostMessage(JsonObject payload);
String sendPostPhoto(JsonObject payload);
String sendPhotoByBinary(const String& chat_id, const String& contentType, int fileSize,
MoreDataAvailable moreDataAvailableCallback,
GetNextByte getNextByteCallback,
GetNextBuffer getNextBufferCallback,
GetNextBufferLen getNextBufferLenCallback);
String sendPhoto(const String& chat_id, const String& photo, const String& caption = "",
bool disable_notification = false,
int reply_to_message_id = 0, const String& keyboard = "");
bool answerCallbackQuery(const String &query_id,
const String &text = "",
bool show_alert = false,
const String &url = "",
int cache_time = 0);
bool setMyCommands(const String& commandArray);
String buildCommand(const String& cmd);
int getUpdates(long offset);
bool checkForOkResponse(const String& response);
telegramMessage messages[HANDLE_MESSAGES];
long last_message_received;
String name;
String userName;
int longPoll = 0;
int waitForResponse = 1500;
int _lastError;
int last_sent_message_id = 0;
int maxMessageLength = 1500;
int jzdelay = 0; // delay between multipart blocks
//int jzblocksize = 32 * 512;
#define jzblocksize 32 * 512
byte buffer[jzblocksize];
private:
// JsonObject * parseUpdates(String response);
String _token;
Client *client;
void closeClient();
bool getFile(String& file_path, long& file_size, const String& file_id);
bool processResult(JsonObject result, int messageIndex);
};
#endif