326 lines
12 KiB
C++
326 lines
12 KiB
C++
#include "./tox_default_impl.hpp"
|
|
|
|
Tox_Connection ToxDefaultImpl::toxSelfGetConnectionStatus(void) {
|
|
return tox_self_get_connection_status(_tox);
|
|
}
|
|
|
|
uint32_t ToxDefaultImpl::toxIterationInterval(void) {
|
|
return tox_iteration_interval(_tox);
|
|
}
|
|
|
|
std::vector<uint8_t> ToxDefaultImpl::toxSelfGetAddress(void) {
|
|
std::vector<uint8_t> self_addr{};
|
|
self_addr.resize(TOX_ADDRESS_SIZE);
|
|
tox_self_get_address(_tox, self_addr.data());
|
|
return self_addr;
|
|
}
|
|
|
|
void ToxDefaultImpl::toxSelfSetNospam(uint32_t nospam) {
|
|
tox_self_set_nospam(_tox, nospam);
|
|
}
|
|
|
|
uint32_t ToxDefaultImpl::toxSelfGetNospam(void) {
|
|
return tox_self_get_nospam(_tox);
|
|
}
|
|
|
|
std::vector<uint8_t> ToxDefaultImpl::toxSelfGetPublicKey(void) {
|
|
std::vector<uint8_t> self_pub{};
|
|
self_pub.resize(TOX_PUBLIC_KEY_SIZE);
|
|
tox_self_get_public_key(_tox, self_pub.data());
|
|
return self_pub;
|
|
}
|
|
|
|
Tox_Err_Set_Info ToxDefaultImpl::toxSelfSetName(std::string_view name) {
|
|
Tox_Err_Set_Info err = TOX_ERR_SET_INFO_OK;
|
|
tox_self_set_name(_tox, reinterpret_cast<const uint8_t*>(name.data()), name.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
std::string ToxDefaultImpl::toxSelfGetName(void) {
|
|
std::string name;
|
|
name.resize(tox_self_get_name_size(_tox));
|
|
tox_self_get_name(_tox, reinterpret_cast<uint8_t*>(name.data()));
|
|
return name;
|
|
}
|
|
|
|
Tox_Err_Set_Info ToxDefaultImpl::toxSelfSetStatusMessage(std::string_view status_message) {
|
|
Tox_Err_Set_Info err = TOX_ERR_SET_INFO_OK;
|
|
tox_self_set_status_message(_tox, reinterpret_cast<const uint8_t*>(status_message.data()), status_message.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
std::string ToxDefaultImpl::toxSelfGetStatusMessage(void) {
|
|
std::string status;
|
|
status.resize(tox_self_get_status_message_size(_tox));
|
|
tox_self_get_status_message(_tox, reinterpret_cast<uint8_t*>(status.data()));
|
|
return status;
|
|
}
|
|
|
|
void ToxDefaultImpl::toxSelfSetStatus(Tox_User_Status status) {
|
|
tox_self_set_status(_tox, status);
|
|
}
|
|
|
|
Tox_User_Status ToxDefaultImpl::toxSelfGetStatus(void) {
|
|
return tox_self_get_status(_tox);
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> ToxDefaultImpl::toxFriendAdd(const std::vector<uint8_t>& address, std::string_view message) {
|
|
// TODO: check size
|
|
Tox_Err_Friend_Add err = TOX_ERR_FRIEND_ADD_OK;
|
|
auto res = tox_friend_add(_tox, address.data(), reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
|
|
if (err == TOX_ERR_FRIEND_ADD_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Add> ToxDefaultImpl::toxFriendAddNorequest(const std::vector<uint8_t>& public_key) {
|
|
// TODO: check size
|
|
Tox_Err_Friend_Add err = TOX_ERR_FRIEND_ADD_OK;
|
|
auto res = tox_friend_add_norequest(_tox, public_key.data(), &err);
|
|
if (err == TOX_ERR_FRIEND_ADD_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
Tox_Err_Friend_Delete ToxDefaultImpl::toxFriendDelete(uint32_t friend_number) {
|
|
Tox_Err_Friend_Delete err = TOX_ERR_FRIEND_DELETE_OK;
|
|
tox_friend_delete(_tox, friend_number, &err);
|
|
return err;
|
|
}
|
|
|
|
std::tuple<std::optional<std::vector<uint8_t>>, Tox_Err_Friend_Get_Public_Key> ToxDefaultImpl::toxFriendGetPublicKey(uint32_t friend_number) {
|
|
std::vector<uint8_t> pub(TOX_PUBLIC_KEY_SIZE);
|
|
Tox_Err_Friend_Get_Public_Key err = TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK;
|
|
tox_friend_get_public_key(_tox, friend_number, pub.data(), &err);
|
|
if (err == TOX_ERR_FRIEND_GET_PUBLIC_KEY_OK) {
|
|
return {pub, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Friend_Send_Message> ToxDefaultImpl::toxFriendSendMessage(uint32_t friend_number, Tox_Message_Type type, std::string_view message) {
|
|
Tox_Err_Friend_Send_Message err = TOX_ERR_FRIEND_SEND_MESSAGE_OK;
|
|
auto res = tox_friend_send_message(_tox, friend_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
|
|
if (err == TOX_ERR_FRIEND_SEND_MESSAGE_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
Tox_Err_Conference_Send_Message ToxDefaultImpl::toxConferenceSendMessage(uint32_t conference_number, Tox_Message_Type type, std::string_view message) {
|
|
Tox_Err_Conference_Send_Message err = TOX_ERR_CONFERENCE_SEND_MESSAGE_OK;
|
|
tox_conference_send_message(_tox, conference_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Friend_Custom_Packet ToxDefaultImpl::toxFriendSendLossyPacket(uint32_t friend_number, const std::vector<uint8_t>& data) {
|
|
Tox_Err_Friend_Custom_Packet err = TOX_ERR_FRIEND_CUSTOM_PACKET_OK;
|
|
tox_friend_send_lossy_packet(_tox, friend_number, data.data(), data.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Friend_Custom_Packet ToxDefaultImpl::toxFriendSendLosslessPacket(uint32_t friend_number, const std::vector<uint8_t>& data) {
|
|
Tox_Err_Friend_Custom_Packet err = TOX_ERR_FRIEND_CUSTOM_PACKET_OK;
|
|
tox_friend_send_lossless_packet(_tox, friend_number, data.data(), data.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Group_New> ToxDefaultImpl::toxGroupNew(Tox_Group_Privacy_State privacy_state, std::string_view group_name, std::string_view name) {
|
|
Tox_Err_Group_New err = TOX_ERR_GROUP_NEW_OK;
|
|
auto res = tox_group_new(_tox, privacy_state, reinterpret_cast<const uint8_t*>(group_name.data()), group_name.size(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), &err);
|
|
if (err == TOX_ERR_GROUP_NEW_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Join> ToxDefaultImpl::toxGroupJoin(const std::vector<uint8_t>& chat_id, std::string_view name, std::string_view password) {
|
|
Tox_Err_Group_Join err = TOX_ERR_GROUP_JOIN_OK;
|
|
// TODO: check size
|
|
auto res = tox_group_join(_tox, chat_id.data(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), reinterpret_cast<const uint8_t*>(password.data()), password.size(), &err);
|
|
if (err == TOX_ERR_GROUP_JOIN_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
std::optional<bool> ToxDefaultImpl::toxGroupIsConnected(uint32_t group_number) {
|
|
Tox_Err_Group_Is_Connected err = TOX_ERR_GROUP_IS_CONNECTED_OK;
|
|
auto res = tox_group_is_connected(_tox, group_number, &err);
|
|
if (err == TOX_ERR_GROUP_IS_CONNECTED_OK) {
|
|
return res;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
Tox_Err_Group_Reconnect ToxDefaultImpl::toxGroupReconnect(uint32_t group_number) {
|
|
Tox_Err_Group_Reconnect err = TOX_ERR_GROUP_RECONNECT_OK;
|
|
tox_group_reconnect(_tox, group_number, &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Group_Leave ToxDefaultImpl::toxGroupLeave(uint32_t group_number, std::string_view part_message) {
|
|
Tox_Err_Group_Leave err = TOX_ERR_GROUP_LEAVE_OK;
|
|
tox_group_leave(_tox, group_number, reinterpret_cast<const uint8_t*>(part_message.data()), part_message.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
std::optional<std::string> ToxDefaultImpl::toxGroupSelfGetName(uint32_t group_number) {
|
|
std::string name;
|
|
|
|
Tox_Err_Group_Self_Query err = TOX_ERR_GROUP_SELF_QUERY_OK;
|
|
const auto size = tox_group_self_get_name_size(_tox, group_number, &err);
|
|
if (err != TOX_ERR_GROUP_SELF_QUERY_OK) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
name.resize(size);
|
|
tox_group_self_get_name(_tox, group_number, reinterpret_cast<uint8_t*>(name.data()), &err);
|
|
|
|
if (err == TOX_ERR_GROUP_SELF_QUERY_OK) {
|
|
return name;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<std::string>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetName(uint32_t group_number, uint32_t peer_id) {
|
|
std::string name;
|
|
|
|
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
|
|
const auto size = tox_group_peer_get_name_size(_tox, group_number, peer_id, &err);
|
|
if (err != TOX_ERR_GROUP_PEER_QUERY_OK) {
|
|
return {std::nullopt, err};
|
|
}
|
|
|
|
name.resize(size);
|
|
tox_group_peer_get_name(_tox, group_number, peer_id, reinterpret_cast<uint8_t*>(name.data()), &err);
|
|
|
|
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
|
|
return {name, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<Tox_Connection>, Tox_Err_Group_Peer_Query> ToxDefaultImpl::toxGroupPeerGetConnectionStatus(uint32_t group_number, uint32_t peer_id) {
|
|
Tox_Err_Group_Peer_Query err = TOX_ERR_GROUP_PEER_QUERY_OK;
|
|
auto res = tox_group_peer_get_connection_status(_tox, group_number, peer_id, &err);
|
|
if (err == TOX_ERR_GROUP_PEER_QUERY_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
Tox_Err_Group_Topic_Set ToxDefaultImpl::toxGroupSetTopic(uint32_t group_number, std::string_view topic) {
|
|
Tox_Err_Group_Topic_Set err = TOX_ERR_GROUP_TOPIC_SET_OK;
|
|
tox_group_set_topic(_tox, group_number, reinterpret_cast<const uint8_t*>(topic.data()), topic.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
std::optional<std::string> ToxDefaultImpl::toxGroupGetTopic(uint32_t group_number) {
|
|
std::string topic;
|
|
|
|
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
|
|
const auto size = tox_group_get_topic_size(_tox, group_number, &err);
|
|
if (err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
topic.resize(size);
|
|
tox_group_get_topic(_tox, group_number, reinterpret_cast<uint8_t*>(topic.data()), &err);
|
|
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
|
|
return topic;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::optional<std::string> ToxDefaultImpl::toxGroupGetName(uint32_t group_number) {
|
|
std::string name;
|
|
|
|
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
|
|
const auto size = tox_group_get_name_size(_tox, group_number, &err);
|
|
if (err != TOX_ERR_GROUP_STATE_QUERIES_OK) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
name.resize(size);
|
|
tox_group_get_name(_tox, group_number, reinterpret_cast<uint8_t*>(name.data()), &err);
|
|
|
|
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
|
|
return name;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::optional<std::vector<uint8_t>> ToxDefaultImpl::toxGroupGetChatId(uint32_t group_number) {
|
|
std::vector<uint8_t> chat_id{};
|
|
chat_id.resize(TOX_GROUP_CHAT_ID_SIZE);
|
|
|
|
Tox_Err_Group_State_Queries err = TOX_ERR_GROUP_STATE_QUERIES_OK;
|
|
tox_group_get_chat_id(_tox, group_number, chat_id.data(), &err);
|
|
if (err == TOX_ERR_GROUP_STATE_QUERIES_OK) {
|
|
return chat_id;
|
|
} else {
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Send_Message> ToxDefaultImpl::toxGroupSendMessage(uint32_t group_number, Tox_Message_Type type, std::string_view message) {
|
|
Tox_Err_Group_Send_Message err = TOX_ERR_GROUP_SEND_MESSAGE_OK;
|
|
uint32_t message_id = 0;
|
|
tox_group_send_message(_tox, group_number, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &message_id, &err);
|
|
if (err == TOX_ERR_GROUP_SEND_MESSAGE_OK) {
|
|
return {message_id, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|
|
Tox_Err_Group_Send_Private_Message ToxDefaultImpl::toxGroupSendPrivateMessage(uint32_t group_number, uint32_t peer_id, Tox_Message_Type type, std::string_view message) {
|
|
Tox_Err_Group_Send_Private_Message err = TOX_ERR_GROUP_SEND_PRIVATE_MESSAGE_OK;
|
|
tox_group_send_private_message(_tox, group_number, peer_id, type, reinterpret_cast<const uint8_t*>(message.data()), message.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Group_Send_Custom_Packet ToxDefaultImpl::toxGroupSendCustomPacket(uint32_t group_number, bool lossless, const std::vector<uint8_t>& data) {
|
|
Tox_Err_Group_Send_Custom_Packet err = TOX_ERR_GROUP_SEND_CUSTOM_PACKET_OK;
|
|
tox_group_send_custom_packet(_tox, group_number, lossless, data.data(), data.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Group_Send_Custom_Private_Packet ToxDefaultImpl::toxGroupSendCustomPrivatePacket(uint32_t group_number, uint32_t peer_id, bool lossless, const std::vector<uint8_t>& data) {
|
|
Tox_Err_Group_Send_Custom_Private_Packet err = TOX_ERR_GROUP_SEND_CUSTOM_PRIVATE_PACKET_OK;
|
|
tox_group_send_custom_private_packet(_tox, group_number, peer_id, lossless, data.data(), data.size(), &err);
|
|
return err;
|
|
}
|
|
|
|
Tox_Err_Group_Invite_Friend ToxDefaultImpl::toxGroupInviteFriend(uint32_t group_number, uint32_t friend_number) {
|
|
Tox_Err_Group_Invite_Friend err = TOX_ERR_GROUP_INVITE_FRIEND_OK;
|
|
tox_group_invite_friend(_tox, group_number, friend_number, &err);
|
|
return err;
|
|
}
|
|
|
|
std::tuple<std::optional<uint32_t>, Tox_Err_Group_Invite_Accept> ToxDefaultImpl::toxGroupInviteAccept(uint32_t friend_number, const std::vector<uint8_t>& invite_data, std::string_view name, std::string_view password) {
|
|
Tox_Err_Group_Invite_Accept err = TOX_ERR_GROUP_INVITE_ACCEPT_OK;
|
|
auto res = tox_group_invite_accept(_tox, friend_number, invite_data.data(), invite_data.size(), reinterpret_cast<const uint8_t*>(name.data()), name.size(), reinterpret_cast<const uint8_t*>(password.data()), password.size(), &err);
|
|
if (err == TOX_ERR_GROUP_INVITE_ACCEPT_OK) {
|
|
return {res, err};
|
|
} else {
|
|
return {std::nullopt, err};
|
|
}
|
|
}
|
|
|