Ditto.hpp

#ifndef DITTO_DITTO_H
#define DITTO_DITTO_H
 
#include "DiskUsage.hpp"
#include "DittoConfig.hpp"
#include "Identity.hpp"
#include "LogLevel.hpp"
#include "Presence.hpp"
#include "SmallPeerInfo.hpp"
#include "TransportConfig.hpp"
 
#include "Helpers.hpp"
 
#include <future>
#include <memory>
 
#ifdef __ANDROID__
#include <jni.h>
#endif /* __ANDROID__ */
 
namespace ditto {
class AuthenticationStatusHandler;
class Authenticator;
class Store;
class StoreObserver;
class Sync;
class SyncSubscription;
 
namespace internal {
struct DittoUnitTest;
} // namespace internal

class Ditto {
  friend class AttachmentFetcher;
  friend class AttachmentFetcherCtx;
  friend class AuthenticationStatusHandler;
  friend class AuthenticationStatusHandlerCtx;
  friend class Authenticator;
  friend class Collection;
  friend class Store;
  friend class StoreObserver;
  friend class Sync;
  friend class SyncSubscription;
 
public:
  static std::shared_ptr<Ditto>
  open(DittoConfig config = DittoConfig::default_config());

  static std::future<std::shared_ptr<Ditto>>
  open_async(DittoConfig config = DittoConfig::default_config());

#ifdef __ANDROID__
  Ditto(jobject android_context,
        std::shared_ptr<Identity> identity = Identity::OfflinePlayground(),
        std::string persistence_dir = "");
#else
  explicit Ditto(
      std::shared_ptr<Identity> identity = Identity::OfflinePlayground(),
      std::string persistence_dir = "");
#endif
 
  Ditto(Ditto const &other) = delete;
  Ditto(Ditto &&other) noexcept;
  Ditto &operator=(Ditto const &other) = delete;
  DITTO_DEPRECATED_BECAUSE("Assigning one Ditto instance to another is not "
                           "supported. Create a new instance instead.")
  Ditto &operator=(Ditto &&other) noexcept;
  ~Ditto();

  std::shared_ptr<Authenticator> get_auth() const;

  Store &get_store() const;

  SmallPeerInfo &get_small_peer_info() const;

  Sync &get_sync() const;

  DITTO_DEPRECATED_BECAUSE("Use get_sync() instead") Sync &sync() const;

  Presence &get_presence() const;

  DiskUsage &get_disk_usage() const;

  TransportConfig get_transport_config() const;

  bool get_is_sync_active() const;

  bool get_is_activated() const;

  void set_offline_only_license_token(std::string license_token);

  void set_device_name(std::string const &name);

  void start_sync() const;

  void stop_sync() const;

  void disable_sync_with_v3() const;

  void set_transport_config(TransportConfig config);

  void
  update_transport_config(std::function<void(TransportConfig &config)> lambda);

  static std::string get_sdk_version();

#ifdef __ANDROID__
  static std::string default_root_directory(JNIEnv *env, jobject context);
#else
  static std::string default_root_directory();
#endif

  static bool get_logging_enabled();

  static void set_logging_enabled(bool enabled);

  static bool get_emoji_log_level_headings_enabled();

  static void set_emoji_log_level_headings_enabled(bool enabled);

  static LogLevel get_minimum_log_level();

  static void set_minimum_log_level(LogLevel log_level);

  void run_garbage_collection() const;

  std::string get_app_id() const;

  DittoConfig get_config() const;

  std::string get_persistence_directory() const;

  std::string get_absolute_persistence_directory() const;

  PresenceObserver observe_peers(PresenceCallback cb);

  void close();
 
#ifdef __ANDROID__
  DITTO_DEPRECATED_BECAUSE(
      "Use the Ditto constructor's `android_context` parameter instead")
  void set_android_context(JNIEnv *env, jobject context);

  std::vector<std::string> missing_permissions() const;

  jobjectArray missing_permissions_jni_array() const;
#endif
 
private:
  // Private Ditto::Fields structure contains the state of a Ditto instance.
  struct Fields;
  std::shared_ptr<Fields> fields;
 
  // TODO(v5) Remove is_closable
  bool is_closable;
 
  explicit Ditto(std::shared_ptr<Fields> fields);
 
  void set_is_closable(bool is_closable);
  std::shared_ptr<DittoHandleWrapper> get_handle_wrapper();
 
  friend struct StoreObserverCtx;
  friend struct ::ditto::internal::DittoUnitTest;
 
  static std::shared_ptr<Ditto> open_ditto_with_config(DittoConfig config);
};
} // namespace ditto
 
#endif