public Vector<TSConnection> connectPredictive(TSDevice device,
			String dialedDigits, int connectionState, int maxRings,
			int answeringTreatment, int answeringEndpointType,
			String destRoute, boolean priorityCall, UserToUserInfo userInfo,
			CSTAPrivate reqPriv) throws TsapiPrivilegeViolationException,
			TsapiInvalidArgumentException, TsapiInvalidPartyException,
			TsapiInvalidStateException, TsapiResourceUnavailableException,
			TsapiMethodNotSupportedException {
		if (this.provider.getCapabilities().getMakePredictiveCall() == 0) {
			throw new TsapiMethodNotSupportedException(4, 0,
					"unsupported by driver");
		}

		if (this.state != 32) {
			throw new TsapiInvalidStateException(3, 0,
					TsapiCreateObject.getTsapiObject(this, false), 1,
					this.state, "call not idle");
		}

		String devName = device.getName();
		short allocState;
		switch (connectionState) {
		case 50:
			allocState = 0;
			break;
		case 51:
			allocState = 1;
			break;
		default:
			throw new TsapiInvalidArgumentException(0, 0,
					"invalid connectionState");
		}
		if (this.provider.isLucent()) {
			short answerTreat;
			switch (answeringTreatment) {
			case 1:
				answerTreat = 1;
				break;
			case 2:
				answerTreat = 2;
				break;
			case 3:
				answerTreat = 3;
				break;
			case 4:
				answerTreat = 0;
				break;
			default:
				throw new TsapiInvalidArgumentException(0, 0,
						"invalid answeringTreatment");
			}
			LucentMakePredictiveCall lmc = createLucentMakePredictiveCall(
					priorityCall, maxRings, answerTreat, destRoute, userInfo);

			reqPriv = lmc.makeTsapiPrivate();
		}

		MakeCallConfHandler handler = new MakeCallConfHandler(this, device,
				dialedDigits, 26);
		try {
			this.provider.tsapi.makePredictiveCall(devName, dialedDigits,
					allocState, reqPriv, handler);
		} catch (TsapiInvalidStateException e) {
			throw e;
		} catch (TsapiInvalidPartyException e) {
			throw e;
		} catch (TsapiInvalidArgumentException e) {
			throw e;
		} catch (TsapiPrivilegeViolationException e) {
			throw e;
		} catch (TsapiResourceUnavailableException e) {
			throw e;
		} catch (TsapiPlatformException e) {
			throw e;
		} catch (Exception e) {
			if ((e instanceof ITsapiException)) {
				throw new TsapiPlatformException(
						((ITsapiException) e).getErrorType(),
						((ITsapiException) e).getErrorCode(),
						"makePredictiveCall failure");
			}
			throw new TsapiPlatformException(4, 0, "makePredictiveCall failure");
		}

		boolean hasPredictiveCallMonitor = device
				.isPredictiveCallsViaDeviceMonitorSet();

		if (this.handOffCall != null) {
			return this.handOffCall.connectPredictiveFinish(handler.newCall,
					hasPredictiveCallMonitor);
		}

		return connectPredictiveFinish(handler.newCall,
				hasPredictiveCallMonitor);
	}