Breaking change in 0.15.1 regarding ApnsClient, ApnsClientBuilder about pushy HOT 4 OPEN

            } else if (this.trustedServerCertificates != null) {
                sslContextBuilder.trustManager(this.trustedServerCertificates);
            /*
              Customization for our project.
             */
            } else if (this.trustManager != null) {
                sslContextBuilder.trustManager(this.trustManager);
            }

            sslContext = sslContextBuilder.build();

   /**
     * Customization for our project.
     */
    public ExtendedApnsClientBuilder setTrustManager(final TrustManager trustManager) {
        this.trustedServerCertificatePemFile = null;
        this.trustedServerCertificateInputStream = null;
        this.trustedServerCertificates = null;
        this.trustManager = trustManager;

        return this;
    }

import java.io.IOException;
import java.net.Socket;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;

import javax.net.ssl.SSLEngine;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509ExtendedTrustManager;

import com.google.common.collect.ImmutableSet;

import org.jetbrains.annotations.NotNull;

/**
 * Dynamic {@link X509ExtendedTrustManager} which permits reloading trusted certificates provided by a cache of
 * certificates.
 * <p>
 * Staleness is determined by reference equality so the cache has to provide the same cached instance until it becomes
 * stale.
 */
public final class DynamicX509ExtendedTrustManager extends X509ExtendedTrustManager {

    static final class AtomicState {

        @NotNull
        private final ImmutableSet<X509Certificate> trustedCertificates;

        @NotNull
        private final X509ExtendedTrustManager trustManager;

        AtomicState(@NotNull ImmutableSet<X509Certificate> trustedCertificates) {
            this.trustedCertificates = trustedCertificates;
            trustManager = newTrustManager(this.trustedCertificates);
        }

        @SuppressWarnings("ReferenceEquality")
        boolean isStale(@NotNull ImmutableSet<X509Certificate> currentCertificates) {
            return trustedCertificates != currentCertificates;
        }

        @NotNull
        X509ExtendedTrustManager getTrustManager() {
            return trustManager;
        }
    }

    @NotNull
    static TrustManagerFactory newTrustManagerFactory(@NotNull Iterable<X509Certificate> trustedCertificates) {
        try {
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null, null);

            int i = 0;
            for (final X509Certificate trustedCertificate : trustedCertificates) {
                String alias = Integer.toString(++i);
                keyStore.setCertificateEntry(alias, trustedCertificate);
            }

            // Set up trust manager factory to use our key store.
            TrustManagerFactory trustManagerFactory =
                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());

            trustManagerFactory.init(keyStore);

            return trustManagerFactory;
        } catch (KeyStoreException | IOException | NoSuchAlgorithmException | CertificateException ex) {
            throw new IllegalStateException("Unable to create new TrustManagerFactory: " + ex, ex);
        }
    }

    @NotNull
    static X509ExtendedTrustManager newTrustManager(@NotNull Iterable<X509Certificate> trustedCertificates) {
        TrustManagerFactory trustManagerFactory = newTrustManagerFactory(trustedCertificates);
        return (X509ExtendedTrustManager) trustManagerFactory.getTrustManagers()[0];
    }

    @NotNull
    private final Supplier<ImmutableSet<X509Certificate>> cachedCertificateSupplier;

    @NotNull
    private final AtomicReference<AtomicState> stateRef = new AtomicReference<>(new AtomicState(ImmutableSet.of()));

    public DynamicX509ExtendedTrustManager(@NotNull Supplier<ImmutableSet<X509Certificate>> cachedCertificateSupplier) {
        this.cachedCertificateSupplier = cachedCertificateSupplier;
    }

    @NotNull
    private X509ExtendedTrustManager getTrustManager() {
        while (true) {
            AtomicState currentState = stateRef.get();
            ImmutableSet<X509Certificate> currentCertificates = cachedCertificateSupplier.get();
            if (!currentState.isStale(currentCertificates)) {
                return currentState.getTrustManager();
            }
            AtomicState updatedState = new AtomicState(currentCertificates);
            if (stateRef.compareAndSet(currentState, updatedState)) {
                return updatedState.getTrustManager();
            }
        }
    }

    @Override
    public void checkClientTrusted(X509Certificate[] x509Certificates, String authType, Socket socket)
            throws CertificateException {
        getTrustManager().checkClientTrusted(x509Certificates, authType, socket);
    }

    @Override
    public void checkServerTrusted(X509Certificate[] x509Certificates, String authType, Socket socket)
            throws CertificateException {
        getTrustManager().checkServerTrusted(x509Certificates, authType, socket);
    }

    @Override
    public void checkClientTrusted(X509Certificate[] x509Certificates, String authType, SSLEngine sslEngine)
            throws CertificateException {
        getTrustManager().checkClientTrusted(x509Certificates, authType, sslEngine);
    }

    @Override
    public void checkServerTrusted(X509Certificate[] x509Certificates, String authType, SSLEngine sslEngine)
            throws CertificateException {
        getTrustManager().checkServerTrusted(x509Certificates, authType, sslEngine);
    }

    @Override
    public void checkClientTrusted(X509Certificate[] x509Certificates, String authType) throws CertificateException {
        getTrustManager().checkClientTrusted(x509Certificates, authType);
    }

    @Override
    public void checkServerTrusted(X509Certificate[] x509Certificates, String authType) throws CertificateException {
        getTrustManager().checkServerTrusted(x509Certificates, authType);
    }

    @Override
    public X509Certificate[] getAcceptedIssuers() {
        return getTrustManager().getAcceptedIssuers();
    }
}