Migration from Java API v3 to v5.0

// Get client store from your custom store. byte++[]++ clientStoreBytes
= // TODO: Load bytes from your custom store


CryptshareConnection connection = new CryptshareConnection(new WebServiceUri(SERVER_URL))
Client client = new Client("sender@domain.com", connection, clientStoreBytes);

// do something like verifications, transfers, ...

// Write encrypted modified client store back into the custom store.
byte[] modifiedClientStoreBytes = client.getStore().save();
// TODO: Save modifiedClientStoreBytes to your custom store

import com.cryptshare.api.++*++; import
org.apache.commons.codec.DecoderException; import
org.apache.commons.codec.binary.Hex;


import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * Implementation of {@link IStore} that persists to a custom source, and encrypts the store.
 */
public class CustomProtectedStore implements IStore {

   private final Map<String, String> storeValues;
   private final IProtectionService protectionService;

   private CustomProtectedStore(IProtectionService protectionService) {
       this.protectionService = protectionService;
       this.storeValues = new HashMap<>();
   }

   /**
    * A default {@link IProtectionService} is used to protect the store:
    * AES encryption, using {@link AesProtectionService} with {@link LinuxKeySourceProvider}.
    *
    * @return An instance of a {@link CustomProtectedStore}, with all values loaded.
    * @throws ClientException If opening fails.
    */
   public static CustomProtectedStore open() throws ClientException {
       // TODO: When your program is run under Windows instead, use the DpApiProtectionService instead of the {@link AesProtectionService}.
       IProtectionService protectionService = new AesProtectionService(new LinuxKeySourceProvider());
       CustomProtectedStore protectedFileStore = new CustomProtectedStore(protectionService);
       protectedFileStore.load();

       return protectedFileStore;
   }

   /**
    * Read from client store
    */
   private void load() throws ClientException {
       try {
           byte[] protectedContent = loadStore();
           if (protectedContent.length == 0) {
               return;
           }

           byte[] unprotectedContent = protectionService.unprotect(protectedContent);
           String storeContent = new String(unprotectedContent, StandardCharsets.UTF_8);

           String[] entries = storeContent.split(";");

           for (String entry : entries) {
               String key = entry.substring(0, entry.indexOf('='));
               String value = entry.substring(entry.indexOf('=') + 1);
               storeValues.put(new String(Hex.decodeHex(key)), value);
           }

       } catch (DecoderException e) {
           throw new ClientException(ClientException.CODE_STORE_ACCESS_FAILED, "Could not read from the client store!", e);
       }
   }

   /**
    * Gets a stored value from the store.
    *
    * @param key Unique key to identify the value. If null, the method returns null.
    * @return The value that corresponds to the given key, or null, if the key was null or not found.
    */
   @Override
   public synchronized String getValue(String key) {
       if (key == null) {
           return null;
       }
       return storeValues.get(key);
   }

   /**
    * Sets a value in the store.
    *
    * @param key Unique key for the value. If null, the method call has no effect.
    * @param value Value to be stored. If null, the method call has no effect.
    */
   @Override
   public synchronized void setValue(String key, String value) {
       if (key == null {{!}}{{!}} value == null) {
           return;
       }
       storeValues.put(key, value);
   }

   /**
    * Removes a specific value from the store.
    *
    * @param key Unique key to identify the value. If null, the method call has no effect.
    */
   @Override
   public synchronized void removeValue(String key) {
       if (key == null) {
           return;
       }
       storeValues.remove(key);
   }

   /**
    * Saves this store object to the custom store.
    */
   @Override
   public synchronized void persist() throws ClientException {
       StringBuilder content = new StringBuilder();
       storeValues.forEach((k, v) -> {
           content.append(Hex.encodeHexString(k.getBytes()));
           content.append("=");
           content.append(v);
           content.append(";");
       });

       byte[] unprotectedContent = content.toString().getBytes(StandardCharsets.UTF_8);
       byte[] protectedContent = protectionService.protect(unprotectedContent);

       saveStore(protectedContent);
   }

   private byte[] loadStore() {
       // TODO: Load bytes from your custom store, e.g. from a file or database.
   }

   private void saveStore(byte[] bytes) {
       // TODO: Save bytes to your custom store, e.g. to a file or database.
   }
}

// Get client store from your custom store. CryptshareConnection
connection = new CryptshareConnection(new WebServiceUri(SERVER++_++URL))
Client client = new Client("sender@domain.com", Locale.ENGLISH,
connection, CustomProtectedStore.open());

// do something like verifications, transfers, ...

// Write encrypted modified client store back into the custom store.
// Info: This step is not necessary anymore.

public class UploadProgressChangedHandler implements IUploadProgressChangedHandler {
   @Override
   public void progressChanged(String currentFileNo, String currentFileName, double bytesUploaded, double bytesTotal, long bytesPerSecond) {
       // do something
   }
}

public class UploadCompleteHandler implements IUploadCompleteHandler {
   @Override
   public void uploadComplete(Map<String, String> urlMappings, Map<String, String> smtpMappings, String serverGenPassword, TransferError transferError,
           String trackingId) {
       // do something
   }
}

public class UploadInterruptedHandler implements IUploadInterruptedHandler {
   @Override
   public void uploadInterrupted(CryptshareException cryptshareException) {
       // do something
   }
}

public class UploadCancelledHeader implements IUploadCancelledHandler {
   @Override
   public void cancelled() {
       // do something
   }
}

// Asynchronous Transfer
client.beginTransfer(transfer, new UploadProgressChangedHandler(), new UploadCompleteHandler(), new UploadInterruptedHandler(), new UploadCancelledHeader(), pollingTimer);

// Synchronous Transfer
client.performTransfer(transfer, new UploadProgressChangedHandler(), new UploadCompleteHandler(), new UploadInterruptedHandler(), new UploadCancelledHeader(), pollingTimer);

List<String> recipients = new ArrayList<>();
recipients.add("user001@cryptshare.com");
recipients.add("user002@cryptshare.com");
Policy policy = client.requestPolicy(recipients);

TransferError error = new TransferError(); List<String> recipients = new
ArrayList<>(); recipients.add("recipient@cryptshare.com");
error.setFailedRecipients(recipients);

TransferError error = new TransferError(); List<String> recipients = new
ArrayList<>(); recipients.add("recipient@cryptshare.com");
error.getFailedRecipients().addAll(recipients);