Getting Started with Peer-to-Peer Sync on Xamarin (UWP, iOS, and Android)

{
    "type":"list",
    "list":[
      {
         "image":{"length":16608,"digest":"sha1-LEFKeUfywGIjASSBa0l/cg5rlm8=","content_type":"image/jpeg","@type":"blob"},
          "value":10,
          "key":"Apples"
      },
      {
        "image":{"length":16608,"digest":"sha1-LEFKeUsswGIjASssSBa0l/cg5rlm8=","content_type":"image/jpeg","@type":"blob"},
        "value":110,
        "key":"oranges"
       }
    ]

}

if (!Database.Exists(DbName, DBPath)) {
    using (var dbZip = new ZipArchive(ResourceLoader.GetEmbeddedResourceStream(typeof(CoreApp).GetTypeInfo().Assembly, $"{DbName}.cblite2.zip"))) {
        dbZip.ExtractToDirectory(DBPath);
    }
}

DB = new Database(DbName, new DatabaseConfiguration() { Directory = DBPath });

var q = QueryBuilder.Select(SelectResult.All())
    .From(DataSource.Database(_db))
    .Where(Meta.ID.EqualTo(Expression.String(CoreApp.DocId)))
    .AddChangeListener((sender, args) =>
    {
        var allResult = args.Results.AllResults();
        var result = allResult[0];
        var dict = result[CoreApp.DB.Name].Dictionary;
        var arr = dict.GetArray(CoreApp.ArrKey);

        if (arr.Count < Items.Count)
            Items = new ObservableConcurrentDictionary<int, SeasonalItem>();

        Parallel.For(0, arr.Count, i =>
        {
            var item = arr[i].Dictionary;
            var name = item.GetString("key");
            var cnt = item.GetInt("value");
            var image = item.GetBlob("image");

            if (_items.ContainsKey(i)) {
                _items[i].Name = name;
                _items[i].Quantity = cnt;
                _items[i].ImageByteArray = image?.Content;
            } else {
                var seasonalItem = new SeasonalItem {
                    Index = i,
                    Name = name,
                    Quantity = cnt,
                    ImageByteArray = image?.Content
                };

                _items.Add(i, seasonalItem);
            }

        });
    });

var listenerConfig = new URLEndpointListenerConfiguration(_db); (1)
listenerConfig.NetworkInterface = GetLocalIPv4(NetworkInterfaceType.Wireless80211) ?? GetLocalIPv4(NetworkInterfaceType.Ethernet);
//listenerConfig.Port = 0; // Dynamic port
listenerConfig.Port = 35262; // Fixed port

switch (CoreApp.ListenerTLSMode) { (2)
    case LISTENER_TLS_MODE.DISABLED:
        listenerConfig.DisableTLS = true;
        listenerConfig.TlsIdentity = null;
        break;
    case LISTENER_TLS_MODE.WITH_ANONYMOUS_AUTH:
        listenerConfig.DisableTLS = false; // Use with anonymous self signed cert if TlsIdentity is null
        listenerConfig.TlsIdentity = null;
        break;
    case LISTENER_TLS_MODE.WITH_BUNDLED_CERT:
        listenerConfig.DisableTLS = false;
        listenerConfig.TlsIdentity = ImportTLSIdentityFromPkc12(ListenerCertLabel);
        break;
    case LISTENER_TLS_MODE.WITH_GENERATED_SELF_SIGNED_CERT:
        listenerConfig.DisableTLS = false;
        listenerConfig.TlsIdentity = CreateIdentityWithCertLabel(ListenerCertLabel);
        break;
}

listenerConfig.EnableDeltaSync = true; (3)

if (CoreApp.RequiresUserAuth) { (4)
    listenerConfig.Authenticator = new ListenerPasswordAuthenticator((sender, username, password) =>
    {
        // ** This is only a sample app to use an existing users credential shared cross platforms.
        //    Developers should use SecureString password properly.
        var found = CoreApp.AllowedUsers.Where(u => username == u.Username && new NetworkCredential(string.Empty, password).Password == u.Password).SingleOrDefault();
        return found != null;
    });
}

_urlEndpointListener = new URLEndpointListener(listenerConfig);

_urlEndpointListener.Start();

public void Broadcast()
{
    if (!IsListening)
        return;

    using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, System.Net.Sockets.ProtocolType.Udp)) {
        socket.EnableBroadcast = true;
        var group = new IPEndPoint(IPAddress.Broadcast, CoreApp.UdpPort);
        var hi = Encoding.ASCII.GetBytes($"{CoreApp.Guid}:{_urlEndpointListener.Urls[0].Host}:{_urlEndpointListener.Port}");
        socket.SendTo(hi, group);

        socket.Close();
    }
}

_urlEndpointListener.Stop();
_urlEndpointListener.Dispose();

{
    Title = "Browser";
    Items = new ObservableCollection<ReplicatorItem>();

    _discovery = new UdpListener(CoreApp.UdpPort);
    _discovery.UdpPacketReceived += DiscoveryOnUdpPacketReceived;
    _discovery.Start();
}

#region discover event
private void DiscoveryOnUdpPacketReceived(object sender, UdpPacketReceivedEventArgs args)
{
    var msg = Encoding.ASCII.GetString(args.Data);
    var msgArr = msg.Split(':');
    var remoteId = Guid.Parse(msgArr[0]);
    if (remoteId == CoreApp.Guid) return;
    var remoteIP = IPAddress.Parse(msgArr[1]);
    var remotePort = Int32.Parse(msgArr[2]);
    var remoteEndpoint = new IPEndPoint(remoteIP, remotePort);

    AddReplicator(remoteEndpoint);
}

public ReplicatorItem(IPEndPoint listenerEndpoint)
{
    _listenerEndpoint = listenerEndpoint;
    StartReplicatorCommand = new Command(() => ExecuteStartReplicatorCommand());
    CreateReplicator(ListenerEndpointString);
}

~ReplicatorItem()
{
    Dispose(disposing: false);
}
#endregion

public void CreateReplicator(string PeerEndpointString)
{
    if(_repl != null) {
        return;
    }

    Uri host = new Uri(PeerEndpointString);
    var dbUrl = new Uri(host, _db.Name);
    var replicatorConfig = new ReplicatorConfiguration(_db, new URLEndpoint(dbUrl)); (1)
    replicatorConfig.ReplicatorType = ReplicatorType.PushAndPull;
    replicatorConfig.Continuous = true;

    if (CoreApp.ListenerTLSMode > 0) {

        // Explicitly allows self signed certificates. By default, only
        // CA signed cert is allowed
        switch (CoreApp.ListenerCertValidationMode) { (2)
            case LISTENER_CERT_VALIDATION_MODE.SKIP_VALIDATION:
                // Use acceptOnlySelfSignedServerCertificate set to true to only accept self signed certs.
                // There is no cert validation
                replicatorConfig.AcceptOnlySelfSignedServerCertificate = true;
                break;

            case LISTENER_CERT_VALIDATION_MODE.ENABLE_VALIDATION_WITH_CERT_PINNING:
                // Use acceptOnlySelfSignedServerCertificate set to false to only accept CA signed certs
                // Self signed certs will fail validation

                replicatorConfig.AcceptOnlySelfSignedServerCertificate = false;

                // Enable cert pinning to only allow certs that match pinned cert

                try {
                    var pinnedCert = LoadSelfSignedCertForListenerFromBundle();
                    replicatorConfig.PinnedServerCertificate = pinnedCert;
                } catch (Exception ex) {
                    Debug.WriteLine($"Failed to load server cert to pin. Will proceed without pinning. {ex}");
                }

                break;

            case LISTENER_CERT_VALIDATION_MODE.ENABLE_VALIDATION:
                // Use acceptOnlySelfSignedServerCertificate set to false to only accept CA signed certs
                // Self signed certs will fail validation. There is no cert pinning
                replicatorConfig.AcceptOnlySelfSignedServerCertificate = false;
                break;
        }
    }

    if (CoreApp.RequiresUserAuth) {
        var user = CoreApp.CurrentUser;
        replicatorConfig.Authenticator = new BasicAuthenticator(user.Username, user.Password); (3)
    }

    _repl = new Replicator(replicatorConfig); (4)
    _listenerToken = _repl.AddChangeListener(ReplicationStatusUpdate);
}

public void ExecuteStartReplicatorCommand()
{
    if (!IsStarted) {
        _repl.Start(); (5)

_repl?.Stop();