protected KeyGenerator(KeyGeneratorSpi keyGenSpi,
    Provider provider,
    String algorithm) 
{
        this.spi = keyGenSpi;
        this.provider = provider;
        this.algorithm = algorithm;
}

Creates a KeyGenerator object.

Parameters:

keyGenSpi - the delegate

provider - the provider

algorithm - the algorithm

  void disableFailover() 
{
        serviceIterator = null;
        initType = 0;
        initParams = null;
        initRandom = null;
}

 public final SecretKey generateKey() 
{
        if (serviceIterator == null) {
            return spi.engineGenerateKey();
        }
        RuntimeException failure = null;
        KeyGeneratorSpi mySpi = spi;
        do {
            try {
                return mySpi.engineGenerateKey();
            } catch (RuntimeException e) {
                if (failure == null) {
                    failure = e;
                }
                mySpi = nextSpi(mySpi, true);
            }
        } while (mySpi != null);
        throw failure;
}

Generates a secret key.

 public final String getAlgorithm() 
{
        return this.algorithm;
}

Returns the algorithm name of this KeyGenerator object.

This is the same name that was specified in one of the getInstance calls that created this KeyGenerator object.

 public static final KeyGenerator getInstance(String algorithm) throws NoSuchAlgorithmException 
{
        return new KeyGenerator(algorithm);
}

Returns a KeyGenerator object that generates secret keys for the specified algorithm.

This method traverses the list of registered security Providers, starting with the most preferred Provider. A new KeyGenerator object encapsulating the KeyGeneratorSpi implementation from the first Provider that supports the specified algorithm is returned.

Note that the list of registered providers may be retrieved via the Security.getProviders() method.

 public static final KeyGenerator getInstance(String algorithm,
    String provider) throws NoSuchAlgorithmException, NoSuchProviderException 
{
        Instance instance = JceSecurity.getInstance("KeyGenerator",
                KeyGeneratorSpi.class, algorithm, provider);
        return new KeyGenerator((KeyGeneratorSpi)instance.impl,
                instance.provider, algorithm);
}

Returns a KeyGenerator object that generates secret keys for the specified algorithm.

A new KeyGenerator object encapsulating the KeyGeneratorSpi implementation from the specified provider is returned. The specified provider must be registered in the security provider list.

Note that the list of registered providers may be retrieved via the Security.getProviders() method.

 public static final KeyGenerator getInstance(String algorithm,
    Provider provider) throws NoSuchAlgorithmException 
{
        Instance instance = JceSecurity.getInstance("KeyGenerator",
                KeyGeneratorSpi.class, algorithm, provider);
        return new KeyGenerator((KeyGeneratorSpi)instance.impl,
                instance.provider, algorithm);
}

Returns a KeyGenerator object that generates secret keys for the specified algorithm.

A new KeyGenerator object encapsulating the KeyGeneratorSpi implementation from the specified Provider object is returned. Note that the specified Provider object does not have to be registered in the provider list.

 public final Provider getProvider() 
{
        synchronized (lock) {
            disableFailover();
            return provider;
        }
}

Returns the provider of this KeyGenerator object.

 public final  void init(SecureRandom random) 
{
        if (serviceIterator == null) {
            spi.engineInit(random);
            return;
        }
        RuntimeException failure = null;
        KeyGeneratorSpi mySpi = spi;
        do {
            try {
                mySpi.engineInit(random);
                initType = I_RANDOM;
                initKeySize = 0;
                initParams = null;
                initRandom = random;
                return;
            } catch (RuntimeException e) {
                if (failure == null) {
                    failure = e;
                }
                mySpi = nextSpi(mySpi, false);
            }
        } while (mySpi != null);
        throw failure;
}

Initializes this key generator.

 public final  void init(AlgorithmParameterSpec params) throws InvalidAlgorithmParameterException 
{
        init(params, JceSecurity.RANDOM);
}

Initializes this key generator with the specified parameter set.

If this key generator requires any random bytes, it will get them using the SecureRandom implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

 public final  void init(int keysize) 
{
        init(keysize, JceSecurity.RANDOM);
}

Initializes this key generator for a certain keysize.

If this key generator requires any random bytes, it will get them using the SecureRandom implementation of the highest-priority installed provider as the source of randomness. (If none of the installed providers supply an implementation of SecureRandom, a system-provided source of randomness will be used.)

 public final  void init(AlgorithmParameterSpec params,
    SecureRandom random) throws InvalidAlgorithmParameterException 
{
        if (serviceIterator == null) {
            spi.engineInit(params, random);
            return;
        }
        Exception failure = null;
        KeyGeneratorSpi mySpi = spi;
        do {
            try {
                mySpi.engineInit(params, random);
                initType = I_PARAMS;
                initKeySize = 0;
                initParams = params;
                initRandom = random;
                return;
            } catch (Exception e) {
                if (failure == null) {
                    failure = e;
                }
                mySpi = nextSpi(mySpi, false);
            }
        } while (mySpi != null);
        if (failure instanceof InvalidAlgorithmParameterException) {
            throw (InvalidAlgorithmParameterException)failure;
        }
        if (failure instanceof RuntimeException) {
            throw (RuntimeException)failure;
        }
        throw new InvalidAlgorithmParameterException("init() failed", failure);
}

Initializes this key generator with the specified parameter set and a user-provided source of randomness.

 public final  void init(int keysize,
    SecureRandom random) 
{
        if (serviceIterator == null) {
            spi.engineInit(keysize, random);
            return;
        }
        RuntimeException failure = null;
        KeyGeneratorSpi mySpi = spi;
        do {
            try {
                mySpi.engineInit(keysize, random);
                initType = I_SIZE;
                initKeySize = keysize;
                initParams = null;
                initRandom = random;
                return;
            } catch (RuntimeException e) {
                if (failure == null) {
                    failure = e;
                }
                mySpi = nextSpi(mySpi, false);
            }
        } while (mySpi != null);
        throw failure;
}

Initializes this key generator for a certain keysize, using a user-provided source of randomness.