generated wrapper without callbacks docs and errors check
This commit is contained in:
parent
c767ebe530
commit
c0601444d9
913
toxygen/tox.py
913
toxygen/tox.py
@ -92,6 +92,22 @@ class Tox:
|
||||
self.file_recv_chunk_cb = None
|
||||
self.friend_lossy_packet_cb = None
|
||||
self.friend_lossless_packet_cb = None
|
||||
self.group_moderation_cb = None
|
||||
self.group_join_fail_cb = None
|
||||
self.group_self_join_cb = None
|
||||
self.group_invite_cb = None
|
||||
self.group_custom_packet_cb = None
|
||||
self.group_private_message_cb = None
|
||||
self.group_private_message_cb = None
|
||||
self.group_message_cb = None
|
||||
self.group_password_cb = None
|
||||
self.group_peer_limit_cb = None
|
||||
self.group_privacy_state_cb = None
|
||||
self.group_topic_cb = None
|
||||
self.group_peer_status_cb = None
|
||||
self.group_peer_name_cb = None
|
||||
self.group_peer_exit_cb = None
|
||||
self.group_peer_join_cb = None
|
||||
|
||||
self.AV = ToxAV(self._tox_pointer)
|
||||
|
||||
@ -1510,3 +1526,900 @@ class Tox:
|
||||
return result
|
||||
elif tox_err_get_port == TOX_ERR_GET_PORT['NOT_BOUND']:
|
||||
raise RuntimeError('The instance was not bound to any port.')
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat instance management
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_new(self, privacy_state, group_name):
|
||||
"""
|
||||
Creates a new group chat.
|
||||
|
||||
This function creates a new group chat object and adds it to the chats array.
|
||||
|
||||
The client should initiate its peer list with self info after calling this function, as
|
||||
the peer_join callback will not be triggered.
|
||||
|
||||
:param privacy_state: The privacy state of the group. If this is set to TOX_GROUP_PRIVACY_STATE_PUBLIC,
|
||||
the group will attempt to announce itself to the DHT and anyone with the Chat ID may join.
|
||||
Otherwise a friend invite will be required to join the group.
|
||||
:param group_name: The name of the group. The name must be non-NULL.
|
||||
|
||||
:return groupnumber on success, UINT32_MAX on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_new(self._tox_pointer, privacy_state, group_name,
|
||||
len(group_name), byref(error))
|
||||
return result
|
||||
|
||||
def group_join(self, chat_id, password):
|
||||
"""
|
||||
Joins a group chat with specified Chat ID.
|
||||
|
||||
This function creates a new group chat object, adds it to the chats array, and sends
|
||||
a DHT announcement to find peers in the group associated with chat_id. Once a peer has been
|
||||
found a join attempt will be initiated.
|
||||
|
||||
:param chat_id: The Chat ID of the group you wish to join. This must be TOX_GROUP_CHAT_ID_SIZE bytes.
|
||||
:param password: The password required to join the group. Set to NULL if no password is required.
|
||||
|
||||
:return groupnumber on success, UINT32_MAX on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_join(self._tox_pointer, chat_id, password, len(password), byref(error))
|
||||
return result
|
||||
|
||||
def group_reconnect(self, groupnumber):
|
||||
"""
|
||||
Reconnects to a group.
|
||||
|
||||
This function disconnects from all peers in the group, then attempts to reconnect with the group.
|
||||
The caller's state is not changed (i.e. name, status, role, chat public key etc.)
|
||||
|
||||
:param groupnumber: The group number of the group we wish to reconnect to.
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_reconnect(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_leave(self, groupnumber, message):
|
||||
"""
|
||||
Leaves a group.
|
||||
|
||||
This function sends a parting packet containing a custom (non-obligatory) message to all
|
||||
peers in a group, and deletes the group from the chat array. All group state information is permanently
|
||||
lost, including keys and role credentials.
|
||||
|
||||
:param groupnumber: The group number of the group we wish to leave.
|
||||
:param message: The parting message to be sent to all the peers. Set to NULL if we do not wish to
|
||||
send a parting message.
|
||||
|
||||
:return True if the group chat instance was successfully deleted.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_leave(self._tox_pointer, groupnumber, message, len(message), byref(error))
|
||||
return result
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group user-visible client information (nickname/status/role/public key)
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_self_set_name(self, groupnumber, name):
|
||||
"""
|
||||
Set the client's nickname for the group instance designated by the given group number.
|
||||
|
||||
Nickname length cannot exceed TOX_MAX_NAME_LENGTH. If length is equal to zero or name is a NULL
|
||||
pointer, the function call will fail.
|
||||
|
||||
:param name: A byte array containing the new nickname.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_set_name(self._tox_pointer, groupnumber, name, len(name), byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_name_size(self, groupnumber):
|
||||
"""
|
||||
Return the length of the client's current nickname for the group instance designated
|
||||
by groupnumber as passed to tox_group_self_set_name.
|
||||
|
||||
If no nickname was set before calling this function, the name is empty,
|
||||
and this function returns 0.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_get_name_size(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_name(self, groupnumber):
|
||||
"""
|
||||
Write the nickname set by tox_group_self_set_name to a byte array.
|
||||
|
||||
If no nickname was set before calling this function, the name is empty,
|
||||
and this function has no effect.
|
||||
|
||||
Call tox_group_self_get_name_size to find out how much memory to allocate for the result.
|
||||
:return nickname
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
size = self.group_self_get_name_size(groupnumber)
|
||||
name = create_string_buffer(size)
|
||||
result = Tox.libtoxcore.tox_group_self_get_name(self._tox_pointer, groupnumber, name, byref(error))
|
||||
return str(name[:size], 'utf-8')
|
||||
|
||||
def group_self_set_status(self, groupnumber, status):
|
||||
|
||||
"""
|
||||
Set the client's status for the group instance. Status must be a TOX_USER_STATUS.
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_set_status(self._tox_pointer, groupnumber, status, byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_status(self, groupnumber):
|
||||
"""
|
||||
returns the client's status for the group instance on success.
|
||||
return value is unspecified on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_get_status(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_role(self, groupnumber):
|
||||
"""
|
||||
returns the client's role for the group instance on success.
|
||||
return value is unspecified on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_get_role(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_peer_id(self, groupnumber):
|
||||
"""
|
||||
returns the client's peer id for the group instance on success.
|
||||
return value is unspecified on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_self_get_peer_id(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_self_get_public_key(self, groupnumber):
|
||||
"""
|
||||
Write the client's group public key designated by the given group number to a byte array.
|
||||
|
||||
This key will be permanently tied to the client's identity for this particular group until
|
||||
the client explicitly leaves the group or gets kicked/banned. This key is the only way for
|
||||
other peers to reliably identify the client across client restarts.
|
||||
|
||||
`public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes.
|
||||
|
||||
:return public key
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
result = Tox.libtoxcore.tox_group_self_get_public_key(self._tox_pointer, groupnumber,
|
||||
key, byref(error))
|
||||
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Peer-specific group state queries.
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_peer_get_name_size(self, groupnumber, peer_id):
|
||||
"""
|
||||
Return the length of the peer's name. If the group number or ID is invalid, the
|
||||
return value is unspecified.
|
||||
|
||||
The return value is equal to the `length` argument received by the last
|
||||
`group_peer_name` callback.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name_size(self._tox_pointer, groupnumber, peer_id, byref(error))
|
||||
return result
|
||||
|
||||
def group_peer_get_name(self, groupnumber, peer_id):
|
||||
"""
|
||||
Write the name of the peer designated by the given ID to a byte
|
||||
array.
|
||||
|
||||
Call tox_group_peer_get_name_size to determine the allocation size for the `name` parameter.
|
||||
|
||||
The data written to `name` is equal to the data received by the last
|
||||
`group_peer_name` callback.
|
||||
|
||||
:param groupnumber: The group number of the group we wish to query.
|
||||
:param peer_id: The ID of the peer whose name we want to retrieve.
|
||||
|
||||
:return name.
|
||||
"""
|
||||
error = c_int()
|
||||
size = self.group_peer_get_name_size(groupnumber, peer_id)
|
||||
name = create_string_buffer(size)
|
||||
result = Tox.libtoxcore.tox_group_peer_get_name(self._tox_pointer, groupnumber, peer_id, name, byref(error))
|
||||
return str(name[:], 'utf-8')
|
||||
|
||||
def group_peer_get_status(self, groupnumber, peer_id):
|
||||
"""
|
||||
Return the peer's user status (away/busy/...). If the ID or group number is
|
||||
invalid, the return value is unspecified.
|
||||
|
||||
The status returned is equal to the last status received through the
|
||||
`group_peer_status` callback.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_peer_get_status(self._tox_pointer, groupnumber, peer_id, byref(error))
|
||||
return result
|
||||
|
||||
def group_peer_get_role(self, groupnumber, peer_id):
|
||||
"""
|
||||
Return the peer's role (user/moderator/founder...). If the ID or group number is
|
||||
invalid, the return value is unspecified.
|
||||
|
||||
The role returned is equal to the last role received through the
|
||||
`group_moderation` callback.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_peer_get_role(self._tox_pointer, groupnumber, peer_id, byref(error))
|
||||
return result
|
||||
|
||||
def group_peer_get_public_key(self, groupnumber, peer_id):
|
||||
"""
|
||||
Write the group public key with the designated peer_id for the designated group number to public_key.
|
||||
|
||||
This key will be parmanently tied to a particular peer until they explicitly leave the group or
|
||||
get kicked/banned, and is the only way to reliably identify the same peer across client restarts.
|
||||
|
||||
`public_key` should have room for at least TOX_GROUP_PEER_PUBLIC_KEY_SIZE bytes.
|
||||
|
||||
:return public key
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
key = create_string_buffer(TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
result = Tox.libtoxcore.tox_group_peer_get_public_key(self._tox_pointer, groupnumber, peer_id,
|
||||
key, byref(error))
|
||||
return bin_to_string(key, TOX_GROUP_PEER_PUBLIC_KEY_SIZE)
|
||||
|
||||
def callback_group_peer_name(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_peer_name` event. Pass NULL to unset.
|
||||
This event is triggered when a peer changes their nickname.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_peer_name_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_peer_name(self._tox_pointer, self.group_peer_name_cb, user_data)
|
||||
|
||||
def callback_group_peer_status(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_peer_status` event. Pass NULL to unset.
|
||||
This event is triggered when a peer changes their status.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_int, c_void_p)
|
||||
self.group_peer_status_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_peer_status(self._tox_pointer, self.group_peer_status_cb, user_data)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat state queries and events.
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_set_topic(self, groupnumber, topic):
|
||||
"""
|
||||
Set the group topic and broadcast it to the rest of the group.
|
||||
|
||||
topic length cannot be longer than TOX_GROUP_MAX_TOPIC_LENGTH. If length is equal to zero or
|
||||
topic is set to NULL, the topic will be unset.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_set_topic(self._tox_pointer, groupnumber, topic, len(topic), byref(error))
|
||||
return result
|
||||
|
||||
def group_get_topic_size(self, groupnumber):
|
||||
"""
|
||||
Return the length of the group topic. If the group number is invalid, the
|
||||
return value is unspecified.
|
||||
|
||||
The return value is equal to the `length` argument received by the last
|
||||
`group_topic` callback.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_topic_size(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_get_topic(self, groupnumber):
|
||||
"""
|
||||
Write the topic designated by the given group number to a byte array.
|
||||
Call tox_group_get_topic_size to determine the allocation size for the `topic` parameter.
|
||||
The data written to `topic` is equal to the data received by the last
|
||||
`group_topic` callback.
|
||||
|
||||
:return topic
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
size = self.group_get_topic_size(groupnumber)
|
||||
topic = create_string_buffer(size)
|
||||
result = Tox.libtoxcore.tox_group_get_topic(self._tox_pointer, groupnumber, topic, byref(error))
|
||||
return str(topic[:size], 'utf-8')
|
||||
|
||||
def group_get_name_size(self, groupnumber):
|
||||
"""
|
||||
Return the length of the group name. If the group number is invalid, the
|
||||
return value is unspecified.
|
||||
"""
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_name_size(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_get_name(self, groupnumber):
|
||||
"""
|
||||
Write the name of the group designated by the given group number to a byte array.
|
||||
Call tox_group_get_name_size to determine the allocation size for the `name` parameter.
|
||||
:return true on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
size = self.group_get_name_size(groupnumber)
|
||||
name = create_string_buffer(size)
|
||||
result = Tox.libtoxcore.tox_group_get_name(self._tox_pointer, groupnumber,
|
||||
name, byref(error))
|
||||
return str(name[:size], 'utf-8')
|
||||
|
||||
def group_get_chat_id(self, groupnumber):
|
||||
"""
|
||||
Write the Chat ID designated by the given group number to a byte array.
|
||||
`chat_id` should have room for at least TOX_GROUP_CHAT_ID_SIZE bytes.
|
||||
:return true on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_chat_id(self._tox_pointer, groupnumber,
|
||||
create_string_buffer(TOX_GROUP_CHAT_ID_SIZE), byref(error))
|
||||
return result
|
||||
|
||||
def group_get_number_groups(self):
|
||||
"""
|
||||
Return the number of groups in the Tox chats array.
|
||||
"""
|
||||
|
||||
result = Tox.libtoxcore.tox_group_get_number_groups(self._tox_pointer)
|
||||
return result
|
||||
|
||||
def group_get_privacy_state(self, groupnumber):
|
||||
"""
|
||||
Return the privacy state of the group designated by the given group number. If group number
|
||||
is invalid, the return value is unspecified.
|
||||
|
||||
The value returned is equal to the data received by the last
|
||||
`group_privacy_state` callback.
|
||||
|
||||
see the `Group chat founder controls` section for the respective set function.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_privacy_state(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_get_peer_limit(self, groupnumber):
|
||||
"""
|
||||
Return the maximum number of peers allowed for the group designated by the given group number.
|
||||
If the group number is invalid, the return value is unspecified.
|
||||
|
||||
The value returned is equal to the data received by the last
|
||||
`group_peer_limit` callback.
|
||||
|
||||
see the `Group chat founder controls` section for the respective set function.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_peer_limit(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_get_password_size(self, groupnumber):
|
||||
"""
|
||||
Return the length of the group password. If the group number is invalid, the
|
||||
return value is unspecified.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_get_password_size(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_get_password(self, groupnumber):
|
||||
"""
|
||||
Write the password for the group designated by the given group number to a byte array.
|
||||
|
||||
Call tox_group_get_password_size to determine the allocation size for the `password` parameter.
|
||||
|
||||
The data received is equal to the data received by the last
|
||||
`group_password` callback.
|
||||
|
||||
see the `Group chat founder controls` section for the respective set function.
|
||||
|
||||
:return true on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
size = self.group_get_password_size(groupnumber)
|
||||
password = create_string_buffer(size)
|
||||
result = Tox.libtoxcore.tox_group_get_password(self._tox_pointer, groupnumber,
|
||||
password, byref(error))
|
||||
return str(password[:size], 'utf-8')
|
||||
|
||||
def callback_group_topic(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_topic` event. Pass NULL to unset.
|
||||
This event is triggered when a peer changes the group topic.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_topic_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_topic(self._tox_pointer, self.group_topic_cb, user_data)
|
||||
|
||||
def callback_group_privacy_state(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_privacy_state` event. Pass NULL to unset.
|
||||
This event is triggered when the group founder changes the privacy state.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_int, c_void_p)
|
||||
self.group_privacy_state_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_privacy_state(self._tox_pointer, self.group_privacy_state_cb, user_data)
|
||||
|
||||
def callback_group_peer_limit(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_peer_limit` event. Pass NULL to unset.
|
||||
This event is triggered when the group founder changes the maximum peer limit.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_void_p)
|
||||
self.group_peer_limit_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_peer_limit(self._tox_pointer, self.group_peer_limit_cb, user_data)
|
||||
|
||||
def callback_group_password(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_password` event. Pass NULL to unset.
|
||||
This event is triggered when the group founder changes the group password.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_password_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_password(self._tox_pointer, self.group_password_cb, user_data)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group message sending
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_send_custom_packet(self, groupnumber, lossless, data):
|
||||
"""
|
||||
Send a custom packet to the group.
|
||||
|
||||
If lossless is true the packet will be lossless. Lossless packet behaviour is comparable
|
||||
to TCP (reliability, arrive in order) but with packets instead of a stream.
|
||||
|
||||
If lossless is false, the packet will be lossy. Lossy packets behave like UDP packets,
|
||||
meaning they might never reach the other side or might arrive more than once (if someone
|
||||
is messing with the connection) or might arrive in the wrong order.
|
||||
|
||||
Unless latency is an issue or message reliability is not important, it is recommended that you use
|
||||
lossless custom packets.
|
||||
|
||||
:param groupnumber: The group number of the group the message is intended for.
|
||||
:param lossless: True if the packet should be lossless.
|
||||
:param data A byte array containing the packet data.
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_send_custom_packet(self._tox_pointer, groupnumber, lossless, data,
|
||||
len(data), byref(error))
|
||||
return result
|
||||
|
||||
def group_send_private_message(self, groupnumber, peer_id, message):
|
||||
"""
|
||||
Send a text chat message to the specified peer in the specified group.
|
||||
|
||||
This function creates a group private message packet and pushes it into the send
|
||||
queue.
|
||||
|
||||
The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
|
||||
must be split by the client and sent as separate messages. Other clients can
|
||||
then reassemble the fragments. Messages may not be empty.
|
||||
|
||||
:param groupnumber: The group number of the group the message is intended for.
|
||||
:param peer_id: The ID of the peer the message is intended for.
|
||||
:param message: A non-NULL pointer to the first element of a byte array containing the message text.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_send_private_message(self._tox_pointer, groupnumber, peer_id, message,
|
||||
len(message), byref(error))
|
||||
return result
|
||||
|
||||
def group_send_message(self, groupnumber, type, message):
|
||||
"""
|
||||
Send a text chat message to the group.
|
||||
|
||||
This function creates a group message packet and pushes it into the send
|
||||
queue.
|
||||
|
||||
The message length may not exceed TOX_MAX_MESSAGE_LENGTH. Larger messages
|
||||
must be split by the client and sent as separate messages. Other clients can
|
||||
then reassemble the fragments. Messages may not be empty.
|
||||
|
||||
:param groupnumber: The group number of the group the message is intended for.
|
||||
:param type: Message type (normal, action, ...).
|
||||
:param message: A non-NULL pointer to the first element of a byte array containing the message text.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_send_message(self._tox_pointer, groupnumber, type, message, len(message),
|
||||
byref(error))
|
||||
return result
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group message receiving
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def callback_group_message(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_message` event. Pass NULL to unset.
|
||||
This event is triggered when the client receives a group message.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_int, c_char_p, c_size_t, c_void_p)
|
||||
self.group_message_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_message(self._tox_pointer, self.group_message_cb, user_data)
|
||||
|
||||
def callback_group_private_message(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_private_message` event. Pass NULL to unset.
|
||||
This event is triggered when the client receives a private message.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_private_message_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_private_message(self._tox_pointer, self.group_private_message_cb, user_data)
|
||||
|
||||
def callback_group_custom_packet(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_custom_packet` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when the client receives a custom packet.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, POINTER(c_uint8), c_void_p)
|
||||
self.group_custom_packet_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_custom_packet(self._tox_pointer, self.group_custom_packet_cb, user_data)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat inviting and join/part events
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_invite_friend(self, groupnumber, friend_number):
|
||||
"""
|
||||
Invite a friend to a group.
|
||||
|
||||
This function creates an invite request packet and pushes it to the send queue.
|
||||
|
||||
:param groupnumber: The group number of the group the message is intended for.
|
||||
:param friend_number: The friend number of the friend the invite is intended for.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_invite_friend(self._tox_pointer, groupnumber, friend_number, byref(error))
|
||||
return result
|
||||
|
||||
def group_invite_accept(self, invite_data, password):
|
||||
"""
|
||||
Accept an invite to a group chat that the client previously received from a friend. The invite
|
||||
is only valid while the inviter is present in the group.
|
||||
|
||||
:param invite_data: The invite data received from the `group_invite` event.
|
||||
:param password: The password required to join the group. Set to NULL if no password is required.
|
||||
:return the groupnumber on success, UINT32_MAX on failure.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_invite_accept(self._tox_pointer, invite_data, len(invite_data), password,
|
||||
len(password), byref(error))
|
||||
return result
|
||||
|
||||
def callback_group_invite(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_invite` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when the client receives a group invite from a friend. The client must store
|
||||
invite_data which is used to join the group via tox_group_invite_accept.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_invite_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_invite(self._tox_pointer, self.group_invite_cb, user_data)
|
||||
|
||||
def callback_group_peer_join(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_peer_join` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when a peer other than self joins the group.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_void_p)
|
||||
self.group_peer_join_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_peer_join(self._tox_pointer, self.group_peer_join_cb, user_data)
|
||||
|
||||
def callback_group_peer_exit(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_peer_exit` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when a peer other than self exits the group.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_char_p, c_size_t, c_void_p)
|
||||
self.group_peer_exit_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_peer_exit(self._tox_pointer, self.group_peer_exit_cb, user_data)
|
||||
|
||||
def callback_group_self_join(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_self_join` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when the client has successfully joined a group. Use this to initialize
|
||||
any group information the client may need.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_void_p)
|
||||
self.group_self_join_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_self_join(self._tox_pointer, self.group_self_join_cb, user_data)
|
||||
|
||||
def callback_group_join_fail(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_join_fail` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when the client fails to join a group.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_int, c_void_p)
|
||||
self.group_join_fail_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_join_fail(self._tox_pointer, self.group_join_fail_cb, user_data)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat founder controls (these only work for the group founder)
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_founder_set_password(self, groupnumber, password):
|
||||
"""
|
||||
Set or unset the group password.
|
||||
|
||||
This function sets the groups password, creates a new group shared state including the change,
|
||||
and distributes it to the rest of the group.
|
||||
|
||||
:param groupnumber: The group number of the group for which we wish to set the password.
|
||||
:param password: The password we want to set. Set password to NULL to unset the password.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_founder_set_password(self._tox_pointer, groupnumber, password,
|
||||
len(password), byref(error))
|
||||
return result
|
||||
|
||||
def group_founder_set_privacy_state(self, groupnumber, privacy_state):
|
||||
"""
|
||||
Set the group privacy state.
|
||||
|
||||
This function sets the group's privacy state, creates a new group shared state
|
||||
including the change, and distributes it to the rest of the group.
|
||||
|
||||
If an attempt is made to set the privacy state to the same state that the group is already
|
||||
in, the function call will be successful and no action will be taken.
|
||||
|
||||
:param groupnumber: The group number of the group for which we wish to change the privacy state.
|
||||
:param privacy_state: The privacy state we wish to set the group to.
|
||||
|
||||
:return true on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_founder_set_privacy_state(self._tox_pointer, groupnumber, privacy_state,
|
||||
byref(error))
|
||||
return result
|
||||
|
||||
def group_founder_set_peer_limit(self, groupnumber, max_peers):
|
||||
"""
|
||||
Set the group peer limit.
|
||||
|
||||
This function sets a limit for the number of peers who may be in the group, creates a new
|
||||
group shared state including the change, and distributes it to the rest of the group.
|
||||
|
||||
:param groupnumber: The group number of the group for which we wish to set the peer limit.
|
||||
:param max_peers: The maximum number of peers to allow in the group.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_founder_set_peer_limit(self._tox_pointer, groupnumber,
|
||||
max_peers, byref(error))
|
||||
return result
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat moderation
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_toggle_ignore(self, groupnumber, peer_id, ignore):
|
||||
"""
|
||||
Ignore or unignore a peer.
|
||||
|
||||
:param groupnumber: The group number of the group the in which you wish to ignore a peer.
|
||||
:param peer_id: The ID of the peer who shall be ignored or unignored.
|
||||
:param ignore: True to ignore the peer, false to unignore the peer.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_toggle_ignore(self._tox_pointer, groupnumber, peer_id, ignore, byref(error))
|
||||
return result
|
||||
|
||||
def group_mod_set_role(self, groupnumber, peer_id, role):
|
||||
"""
|
||||
Set a peer's role.
|
||||
|
||||
This function will first remove the peer's previous role and then assign them a new role.
|
||||
It will also send a packet to the rest of the group, requesting that they perform
|
||||
the role reassignment. Note: peers cannot be set to the founder role.
|
||||
|
||||
:param groupnumber: The group number of the group the in which you wish set the peer's role.
|
||||
:param peer_id: The ID of the peer whose role you wish to set.
|
||||
:param role: The role you wish to set the peer to.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_mod_set_role(self._tox_pointer, groupnumber, peer_id, role, byref(error))
|
||||
return result
|
||||
|
||||
def group_mod_remove_peer(self, groupnumber, peer_id, set_ban):
|
||||
"""
|
||||
Kick/ban a peer.
|
||||
|
||||
This function will remove a peer from the caller's peer list and optionally add their IP address
|
||||
to the ban list. It will also send a packet to all group members requesting them
|
||||
to do the same.
|
||||
|
||||
:param groupnumber: The group number of the group the ban is intended for.
|
||||
:param peer_id: The ID of the peer who will be kicked and/or added to the ban list.
|
||||
:param set_ban: Set to true if a ban shall be set on the peer's IP address.
|
||||
|
||||
:return True on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_mod_remove_peer(self._tox_pointer, groupnumber, peer_id,
|
||||
set_ban, byref(error))
|
||||
return result
|
||||
|
||||
def group_mod_remove_ban(self, groupnumber, ban_id):
|
||||
"""
|
||||
Removes a ban.
|
||||
|
||||
This function removes a ban entry from the ban list, and sends a packet to the rest of
|
||||
the group requesting that they do the same.
|
||||
|
||||
:param groupnumber: The group number of the group in which the ban is to be removed.
|
||||
:param ban_id: The ID of the ban entry that shall be removed.
|
||||
|
||||
:return True on success
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_mod_remove_ban(self._tox_pointer, groupnumber, ban_id, byref(error))
|
||||
return result
|
||||
|
||||
def callback_group_moderation(self, callback, user_data):
|
||||
"""
|
||||
Set the callback for the `group_moderation` event. Pass NULL to unset.
|
||||
|
||||
This event is triggered when a moderator or founder executes a moderation event.
|
||||
"""
|
||||
|
||||
c_callback = CFUNCTYPE(None, c_void_p, c_uint32, c_uint32, c_uint32, c_int, c_void_p)
|
||||
self.group_moderation_cb = c_callback(callback)
|
||||
Tox.libtoxcore.tox_callback_group_moderation(self._tox_pointer, self.group_moderation_cb, user_data)
|
||||
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
# Group chat ban list queries
|
||||
# -----------------------------------------------------------------------------------------------------------------
|
||||
|
||||
def group_ban_get_list_size(self, groupnumber):
|
||||
"""
|
||||
Return the number of entries in the ban list for the group designated by
|
||||
the given group number. If the group number is invalid, the return value is unspecified.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_ban_get_list_size(self._tox_pointer, groupnumber, byref(error))
|
||||
return result
|
||||
|
||||
def group_ban_get_list(self, groupnumber):
|
||||
"""
|
||||
Copy a list of valid ban list ID's into an array.
|
||||
|
||||
Call tox_group_ban_get_list_size to determine the number of elements to allocate.
|
||||
return true on success.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_ban_get_list(self._tox_pointer, groupnumber, POINTER(c_uint32)(
|
||||
create_string_buffer(sizeof(c_uint32) * self.group_ban_get_list_size(groupnumber)), byref(error)))
|
||||
return result
|
||||
|
||||
def group_ban_get_name_size(self, groupnumber, ban_id):
|
||||
"""
|
||||
Return the length of the name for the ban list entry designated by ban_id, in the
|
||||
group designated by the given group number. If either groupnumber or ban_id is invalid,
|
||||
the return value is unspecified.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_ban_get_name_size(self._tox_pointer, groupnumber, ban_id, byref(error))
|
||||
return result
|
||||
|
||||
def group_ban_get_name(self, groupnumber, ban_id):
|
||||
"""
|
||||
Write the name of the ban entry designated by ban_id in the group designated by the
|
||||
given group number to a byte array.
|
||||
|
||||
Call tox_group_ban_get_name_size to find out how much memory to allocate for the result.
|
||||
|
||||
:return name
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
size = self.group_ban_get_name_size(groupnumber, ban_id)
|
||||
name = create_string_buffer()
|
||||
|
||||
result = Tox.libtoxcore.tox_group_ban_get_name(self._tox_pointer, groupnumber, ban_id,
|
||||
name, byref(error))
|
||||
return str(name[:size], 'utf-8')
|
||||
|
||||
def group_ban_get_time_set(self, groupnumber, ban_id):
|
||||
"""
|
||||
Return a time stamp indicating the time the ban was set, for the ban list entry
|
||||
designated by ban_id, in the group designated by the given group number.
|
||||
If either groupnumber or ban_id is invalid, the return value is unspecified.
|
||||
"""
|
||||
|
||||
error = c_int()
|
||||
result = Tox.libtoxcore.tox_group_ban_get_time_set(self._tox_pointer, groupnumber, ban_id, byref(error))
|
||||
return result
|
||||
|
Loading…
Reference in New Issue
Block a user