Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-12-01 04:46:47 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Fix compilation, retrocompatibility and enums

Browse source 
Workaround miss-behaviour on old Android phones
Cleanup indentation a bit
Consistent param naming
Introduce default parameter values also for output paramethers
This commit is contained in:
Gioacchino Mazzurco 2019-04-05 01:43:23 +02:00
parent 44c1f1580f
commit ab80d9a374
No known key found for this signature in database
GPG key ID: A1FBCA3872E87051
8 changed files with 584 additions and 365 deletions
Download patch file Download diff file Expand all files Collapse all files

191
libretroshare/src/retroshare/rsgxschannels.h
View file

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright (C) 2012 Robert Fernie <retroshare@lunamutt.com> *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -33,6 +33,8 @@
#include "serialiser/rsserializable.h"
#include "retroshare/rsturtle.h"
#include "util/rsdeprecate.h"
#include "retroshare/rsgxscircles.h"
#include "util/rsmemory.h"
class RsGxsChannels;
@ -99,94 +101,101 @@ public:
explicit RsGxsChannels(RsGxsIface& gxs) : RsGxsIfaceHelper(gxs) {}
virtual ~RsGxsChannels() {}
#ifdef REMOVED
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @param[inout] channel Channel data (name, description...)
* @return false on error, true otherwise
* @param[in] name Name of the channel
* @param[in] description Description of the channel
* @param[in] thumbnail Optional image to show as channel thumbnail.
* @param[in] authorId Optional id of the author. Leave empty for an
* anonymous channel.
* @param[in] circleType Optional visibility rule, default public.
* @param[in] circleId If the channel is not public specify the id of the
* circle who can see the channel. Depending on the value you pass for
* circleType this should be be an external circle if EXTERNAL is passed, a
* local friend group id if NODES_GROUP is passed, empty otherwise.
* @param[out] channelId Optional storage for the id of the created channel,
* meaningful only if creations succeeds.
* @param[out] errorMessage Optional storage for error messsage, meaningful
* only if creation fail.
* @return False on error, true otherwise.
*/
virtual bool createChannel(RsGxsChannelGroup& channel) = 0;
#endif
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @param[in] name Name of the channel
* @param[in] description Description of the channel
* @param[in] image Thumbnail that is shown to advertise the channel. Possibly empty.
* @param[in] author_id GxsId of the contact author. For an anonymous channel, leave this to RsGxsId()="00000....0000"
* @param[in] circle_type Type of visibility restriction, among { GXS_CIRCLE_TYPE_PUBLIC, GXS_CIRCLE_TYPE_EXTERNAL, GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY, GXS_CIRCLE_TYPE_YOUR_EYES_ONLY }
* @param[in] circle_id Id of the circle (should be an external circle for GXS_CIRCLE_TYPE_EXTERNAL, a local friend group for GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY, GxsCircleId()="000....000" otherwise
* @param[out] channel_group_id Group id of the created channel, if command succeeds.
* @param[out] error_message Error messsage supplied when the channel creation fails.
* @return False on error, true otherwise.
*/
virtual bool createChannel(const std::string& name,
const std::string& description,
const RsGxsImage& image,
const RsGxsId& author_id,
uint32_t circle_type,
RsGxsCircleId& circle_id,
RsGxsGroupId& channel_group_id,
std::string& error_message )=0;
virtual bool createChannelV2(
const std::string& name, const std::string& description,
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsId& authorId = RsGxsId(),
RsGxsCircleType circleType = RsGxsCircleType::PUBLIC,
const RsGxsCircleId& circleId = RsGxsCircleId(),
RsGxsGroupId& channelId = RS_DEFAULT_STORAGE_PARAM(RsGxsGroupId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief Add a comment on a post or on another comment
* @jsonapi{development}
* @param[in] groupId Id of the channel in which the comment is to be posted
* @param[in] parentMsgId Id of the parent of the comment that is either a channel post Id or the Id of another comment.
* @param[in] comment UTF-8 string containing the comment
* @param[out] commentMessageId Id of the comment that was created
* @param[out] error_string Error message supplied when the comment creation fails.
* @param[in] channelId Id of the channel in which the comment is to be posted
* @param[in] parentId Id of the parent of the comment that is either a
* channel post Id or the Id of another comment.
* @param[in] comment UTF-8 string containing the comment
* @param[out] commentMessageId Optional storage for the id of the comment
* that was created, meaningful only on success.
* @param[out] errorMessage Optional storage for error message, meaningful
* only on failure.
* @return false on error, true otherwise
*/
virtual bool createComment(const RsGxsGroupId& groupId,
const RsGxsMessageId& parentMsgId,
const std::string& comment,
RsGxsMessageId& commentMessageId,
std::string& error_message )=0;
virtual bool createCommentV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& parentId,
const std::string& comment,
RsGxsMessageId& commentMessageId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) )=0;
/**
* @brief Create channel post. Blocking API.
* @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!)
* @param[in] origMsgId Id of the post you are replacing. If left blank (RsGxsMssageId()="0000.....0000", a new post will be created
* @param[in] msgName Title of the post
* @param[in] msg Text content of the post
* @param[in] files List of attached files. These are supposed to be shared otherwise (use ExtraFileHash() below)
* @param[in] thumbnail Image displayed in the list of posts. Can be left blank.
* @param[out] messsageId Id of the message that was created
* @param[out] error_message Error text if anything bad happens
* @param[in] channelId Id of the channel where to put the post. Beware you
* need publish rights on that channel to post.
* @param[in] title Title of the post
* @param[in] mBody Text content of the post
* @param[in] files Optional list of attached files. These are supposed to
* be already shared, @see ExtraFileHash() below otherwise.
* @param[in] thumbnail Optional thumbnail image for the post.
* @param[in] origPostId If this is supposed to replace an already existent
* post, the id of the old post. If left blank a new post will be created.
* @param[out] postId Optional storage for the id of the created post,
* meaningful only on success.
* @param[out] errorMessage Optional storage for the error message,
* meaningful only on failure.
* @return false on error, true otherwise
*/
virtual bool createPost(const RsGxsGroupId& groupId,
const RsGxsMessageId& origMsgId,
const std::string& msgName,
const std::string& msg,
const std::list<RsGxsFile>& files,
const RsGxsImage& thumbnail,
RsGxsMessageId& messageId,
std::string& error_message) = 0;
virtual bool createPostV2(
const RsGxsGroupId& channelId, const std::string& title,
const std::string& mBody,
const std::list<RsGxsFile>& files = std::list<RsGxsFile>(),
const RsGxsImage& thumbnail = RsGxsImage(),
const RsGxsMessageId& origPostId = RsGxsMessageId(),
RsGxsMessageId& postId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief createVote
* @brief Create a vote
* @jsonapi{development}
* @param[in] groupId Id of the channel where to put the post (publish rights needed!)
* @param[in] threadId Id of the channel post in which a comment is voted
* @param[in] commentMesssageId Id of the comment that is voted
* @param[in] authorId Id of the author. Needs to be your identity.
* @param[in] voteType Type of vote (GXS_VOTE_NONE=0x00, GXS_VOTE_DOWN=0x01, GXS_VOTE_UP=0x02)
* @param[out] voteMessageId Id of the vote message produced
* @param[out] error_message Error text if anything bad happens
* @param[in] channelId Id of the channel where to vote
* @param[in] postId Id of the channel post of which a comment is voted
* @param[in] commentId Id of the comment that is voted
* @param[in] authorId Id of the author. Needs to be of an owned identity.
* @param[in] vote Vote value, either RsGxsVoteType::DOWN or
* RsGxsVoteType::UP
* @param[out] voteId Optional storage for the id of the created vote,
* meaningful only on success.
* @param[out] errorMessage Optional storage for error message, meaningful
* only on failure.
* @return false on error, true otherwise
*/
virtual bool createVote( const RsGxsGroupId& groupId,
const RsGxsMessageId& threadId,
const RsGxsMessageId& commentMessageId,
const RsGxsId& authorId,
uint32_t voteType,
RsGxsMessageId& voteMessageId,
std::string& error_message)=0;
virtual bool createVoteV2(
const RsGxsGroupId& channelId, const RsGxsMessageId& postId,
const RsGxsMessageId& commentId, const RsGxsId& authorId,
RsGxsVoteType vote,
RsGxsMessageId& voteId = RS_DEFAULT_STORAGE_PARAM(RsGxsMessageId),
std::string& errorMessage = RS_DEFAULT_STORAGE_PARAM(std::string) ) = 0;
/**
* @brief Edit channel details.
@ -372,6 +381,16 @@ public:
/* Following functions are deprecated as they expose internal functioning
* semantic, instead of a safe to use API */
/**
* @brief Create channel. Blocking API.
* @jsonapi{development}
* @deprecated { substituted by createChannelV2 }
* @param[inout] channel Channel data (name, description...)
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createChannelV2)
virtual bool createChannel(RsGxsChannelGroup& channel) = 0;
RS_DEPRECATED_FOR(getChannelsInfo)
virtual bool getGroupData(const uint32_t &token, std::vector<RsGxsChannelGroup> &groups) = 0;
@ -429,9 +448,29 @@ public:
* @param[in] group Channel data (name, description...)
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createChannel)
RS_DEPRECATED_FOR(createChannelV2)
virtual bool createGroup(uint32_t& token, RsGxsChannelGroup& group) = 0;
/**
* @brief Add a comment on a post or on another comment
* @jsonapi{development}
* @deprecated
* @param[inout] comment
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createCommentV2)
virtual bool createComment(RsGxsComment& comment) = 0;
/**
* @brief Create channel post. Blocking API.
* @jsonapi{development}
* @deprecated
* @param[inout] post
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(RsGxsChannelPost& post) = 0;
/**
* @brief Request post creation.
* The action is performed asyncronously, so it could fail in a subsequent
@ -442,9 +481,19 @@ public:
* @param[in] post
* @return false on error, true otherwise
*/
RS_DEPRECATED
RS_DEPRECATED_FOR(createPostV2)
virtual bool createPost(uint32_t& token, RsGxsChannelPost& post) = 0;
/**
* @brief createVote
* @jsonapi{development}
* @deprecated
* @param[inout] vote
* @return false on error, true otherwise
*/
RS_DEPRECATED_FOR(createVoteV2)
virtual bool createVote(RsGxsVote& vote) = 0;
/**
* @brief Request channel change.
* The action is performed asyncronously, so it could fail in a subsequent

69
libretroshare/src/retroshare/rsgxscircles.h
View file

@ -42,24 +42,35 @@ class RsGxsCircles;
*/
extern RsGxsCircles* rsGxsCircles;
enum class RsGxsCircleType : uint32_t // 32 bit overkill, just for retrocompat
{
UNKNOWN = 0, /// Used to detect uninizialized values.
PUBLIC = 1, /// Public distribution
EXTERNAL = 2, /// Restricted to an external circle
// TODO: convert to enum
/// The meaning of the different circle types is:
static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000 ; /// Used to detect uninizialized values.
static const uint32_t GXS_CIRCLE_TYPE_PUBLIC = 0x0001 ; // not restricted to a circle
static const uint32_t GXS_CIRCLE_TYPE_EXTERNAL = 0x0002 ; // restricted to an external circle, made of RsGxsId
static const uint32_t GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY = 0x0003 ; // restricted to a subset of friend nodes of a given RS node given by a RsPgpId list
static const uint32_t GXS_CIRCLE_TYPE_LOCAL = 0x0004 ; // not distributed at all
static const uint32_t GXS_CIRCLE_TYPE_EXT_SELF = 0x0005 ; // self-restricted. Not used, except at creation time when the circle ID isn't known yet. Set to EXTERNAL afterwards.
static const uint32_t GXS_CIRCLE_TYPE_YOUR_EYES_ONLY = 0x0006 ; // distributed to nodes signed by your own PGP key only.
/** Restricted to a group of friend nodes, the administrator of the circle
* behave as a hub for them */
NODES_GROUP = 3,
LOCAL = 4, /// not distributed at all
/** Self-restricted. Used only at creation time of self-restricted circles
* when the circle id isn't known yet. Once the circle id is known the type
* is set to EXTERNAL, and the external circle id is set to the id of the
* circle itself.
*/
EXT_SELF = 5,
/// distributed to nodes signed by your own PGP key only.
YOUR_EYES_ONLY = 6
};
// TODO: convert to enum class
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_IN_ADMIN_LIST = 0x0001 ;// user is validated by circle admin
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_SUBSCRIBED = 0x0002 ;// user has subscribed the group
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_KEY_AVAILABLE = 0x0004 ;// key is available, so we can encrypt for this circle
static const uint32_t GXS_EXTERNAL_CIRCLE_FLAGS_ALLOWED = 0x0007 ;// user is allowed. Combines all flags above.
static const uint32_t GXS_CIRCLE_FLAGS_IS_EXTERNAL = 0x0008 ;// user is allowed
struct RsGxsCircleGroup : RsSerializable
{
@ -110,8 +121,9 @@ struct RsGxsCircleMsg : RsSerializable
struct RsGxsCircleDetails : RsSerializable
{
RsGxsCircleDetails() :
mCircleType(GXS_CIRCLE_TYPE_EXTERNAL), mAmIAllowed(false) {}
~RsGxsCircleDetails() {}
mCircleType(static_cast<uint32_t>(RsGxsCircleType::EXTERNAL)),
mAmIAllowed(false) {}
~RsGxsCircleDetails() override {}
RsGxsCircleId mCircleId;
std::string mCircleName;
@ -264,3 +276,34 @@ public:
RS_DEPRECATED_FOR("editCircle, inviteIdsToCircle")
virtual void updateGroup(uint32_t &token, RsGxsCircleGroup &group) = 0;
};
/// @deprecated Used to detect uninizialized values.
RS_DEPRECATED_FOR("RsGxsCircleType::UNKNOWN")
static const uint32_t GXS_CIRCLE_TYPE_UNKNOWN = 0x0000;
/// @deprecated not restricted to a circle
RS_DEPRECATED_FOR("RsGxsCircleType::PUBLIC")
static const uint32_t GXS_CIRCLE_TYPE_PUBLIC = 0x0001;
/// @deprecated restricted to an external circle, made of RsGxsId
RS_DEPRECATED_FOR("RsGxsCircleType::EXTERNAL")
static const uint32_t GXS_CIRCLE_TYPE_EXTERNAL = 0x0002;
/// @deprecated restricted to a subset of friend nodes of a given RS node given
/// by a RsPgpId list
RS_DEPRECATED_FOR("RsGxsCircleType::NODES_GROUP")
static const uint32_t GXS_CIRCLE_TYPE_YOUR_FRIENDS_ONLY = 0x0003;
/// @deprecated not distributed at all
RS_DEPRECATED_FOR("RsGxsCircleType::LOCAL")
static const uint32_t GXS_CIRCLE_TYPE_LOCAL = 0x0004;
/// @deprecated self-restricted. Not used, except at creation time when the
/// circle ID isn't known yet. Set to EXTERNAL afterwards.
RS_DEPRECATED_FOR("RsGxsCircleType::EXT_SELF")
static const uint32_t GXS_CIRCLE_TYPE_EXT_SELF = 0x0005;
/// @deprecated distributed to nodes signed by your own PGP key only.
RS_DEPRECATED_FOR("RsGxsCircleType::YOUR_EYES_ONLY")
static const uint32_t GXS_CIRCLE_TYPE_YOUR_EYES_ONLY = 0x0006;

24
libretroshare/src/retroshare/rsgxscommon.h
View file

@ -19,11 +19,9 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#pragma once
#ifndef RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H
#define RETROSHARE_GXS_COMMON_OBJS_INTERFACE_H
#include <inttypes.h>
#include <cstdint>
#include <string>
#include <list>
@ -79,10 +77,12 @@ struct RsGxsImage : RsSerializable
}
};
#define GXS_VOTE_NONE 0x0000
#define GXS_VOTE_DOWN 0x0001
#define GXS_VOTE_UP 0x0002
enum class RsGxsVoteType : uint32_t
{
NONE = 0, /// Used to detect unset vote?
DOWN = 1, /// Negative vote
UP = 2 /// Positive vote
};
// Status Flags to indicate Voting....
@ -181,7 +181,11 @@ struct RsGxsCommentService
std::pair<RsGxsGroupId, RsGxsMessageId>& msgId ) = 0;
};
/// @deprecated use RsGxsVoteType::NONE instead @see RsGxsVoteType
#define GXS_VOTE_NONE 0x0000
/// @deprecated use RsGxsVoteType::DOWN instead @see RsGxsVoteType
#define GXS_VOTE_DOWN 0x0001
#endif
/// @deprecated use RsGxsVoteType::UP instead @see RsGxsVoteType
#define GXS_VOTE_UP 0x0002

44
libretroshare/src/retroshare/rsgxsifacehelper.h
View file

@ -4,7 +4,7 @@
* libretroshare: retroshare core library *
* *
* Copyright 2011 by Christopher Evi-Parker *
* Copyright (C) 2018 Gioacchino Mazzurco <gio@eigenlab.org> *
* Copyright (C) 2018-2019 Gioacchino Mazzurco <gio@eigenlab.org> *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
@ -20,9 +20,7 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. *
* *
*******************************************************************************/
#ifndef RSGXSIFACEIMPL_H
#define RSGXSIFACEIMPL_H
#pragma once
#include <chrono>
#include <thread>
@ -292,19 +290,51 @@ protected:
* Useful for blocking API implementation.
* @param[in] token token associated to the request caller is waiting for
* @param[in] maxWait maximum waiting time in milliseconds
* @param[in] checkEvery time in millisecond between status checks
*/
RsTokenService::GxsRequestStatus waitToken(
uint32_t token,
std::chrono::milliseconds maxWait = std::chrono::milliseconds(500) )
std::chrono::milliseconds maxWait = std::chrono::milliseconds(500),
std::chrono::milliseconds checkEvery = std::chrono::milliseconds(2))
{
#if defined(__ANDROID__) && (__ANDROID_API__ < 24)
auto wkStartime = std::chrono::steady_clock::now();
int maxWorkAroundCnt = 10;
LLwaitTokenBeginLabel:
#endif
auto timeout = std::chrono::steady_clock::now() + maxWait;
auto st = requestStatus(token);
while( !(st == RsTokenService::FAILED || st >= RsTokenService::COMPLETE)
&& std::chrono::steady_clock::now() < timeout )
{
std::this_thread::sleep_for(std::chrono::milliseconds(2));
std::this_thread::sleep_for(checkEvery);
st = requestStatus(token);
}
#if defined(__ANDROID__) && (__ANDROID_API__ < 24)
/* Work around for very slow/old android devices, we don't expect this
* to be necessary on newer devices. If it take unreasonably long
* something worser is already happening elsewere amd we return anyway.
*/
if( st > RsTokenService::FAILED && st < RsTokenService::COMPLETE
&& maxWorkAroundCnt-- > 0 )
{
maxWait *= 10;
checkEvery *= 3;
std::cerr << __PRETTY_FUNCTION__ << " Slow Android device "
<< " workaround st: " << st
<< " maxWorkAroundCnt: " << maxWorkAroundCnt
<< " maxWait: " << maxWait.count()
<< " checkEvery: " << checkEvery.count() << std::endl;
goto LLwaitTokenBeginLabel;
}
std::cerr << __PRETTY_FUNCTION__ << " lasted: "
<< std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - wkStartime ).count()
<< "ms" << std::endl;
#endif
return st;
}
@ -312,5 +342,3 @@ private:
RsGxsIface& mGxs;
RsTokenService& mTokenService;
};
#endif // RSGXSIFACEIMPL_H

13
libretroshare/src/retroshare/rstokenservice.h
View file

@ -121,15 +121,14 @@ public:
enum GxsRequestStatus : uint8_t
{
FAILED,
PENDING,
PARTIAL,
COMPLETE,
DONE, /// Once all data has been retrived
CANCELLED
FAILED = 0,
PENDING = 1,
PARTIAL = 2,
COMPLETE = 3,
DONE = 4, /// Once all data has been retrived
CANCELLED = 5
};
RsTokenService() {}
virtual ~RsTokenService() {}