smpptest.java

Short Message Peer to Peer

			debug.exit(this);
		}
	}

	/**
	 * Ubinds (logs out) from the SMSC and closes the connection.
	 *
	 * See "SMPP Protocol Specification 3.4, 4.2 UNBIND Operation."
	 * @see Session#unbind()
	 * @see Unbind
	 * @see UnbindResp
	 */
	private void unbind() {
		debug.enter(this, "SMPPTest.unbind()");
		try {

			if (!bound) {
				System.out.println("Not bound, cannot unbind.");
				return;
			}

			// send the request
			System.out.println("Going to unbind.");
			if (session.getReceiver().isReceiver()) {
				System.out.println("It can take a while to stop the receiver.");
			}
			UnbindResp response = session.unbind();
			System.out.println("Unbind response " + response.debugString());
			bound = false;

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Unbind operation failed. " + e);
			System.out.println("Unbind operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>SubmitSM</code> class, lets you set
	 * subset of fields of it. This PDU is used to send SMS message
	 * to a device.
	 *
	 * See "SMPP Protocol Specification 3.4, 4.4 SUBMIT_SM Operation."
	 * @see Session#submit(SubmitSM)
	 * @see SubmitSM
	 * @see SubmitSMResp
	 */
	private void submit() {
		debug.enter(this, "SMPPTest.submit()");

		try {
			SubmitSM request = new SubmitSM();
			SubmitSMResp response;

			// input values
			serviceType = getParam("Service type", serviceType);
			sourceAddress = getAddress("Source", sourceAddress);
			destAddress = getAddress("Destination", destAddress);
			replaceIfPresentFlag = getParam("Replace if present flag", replaceIfPresentFlag);
			shortMessage = getParam("The short message", shortMessage);
			scheduleDeliveryTime = getParam("Schedule delivery time", scheduleDeliveryTime);
			validityPeriod = getParam("Validity period", validityPeriod);
			esmClass = getParam("Esm class", esmClass);
			protocolId = getParam("Protocol id", protocolId);
			priorityFlag = getParam("Priority flag", priorityFlag);
			registeredDelivery = getParam("Registered delivery", registeredDelivery);
			dataCoding = getParam("Data encoding", dataCoding);
			smDefaultMsgId = getParam("Sm default msg id", smDefaultMsgId);

			// set values
			request.setServiceType(serviceType);
			request.setSourceAddr(sourceAddress);
			request.setDestAddr(destAddress);
			request.setReplaceIfPresentFlag(replaceIfPresentFlag);
			request.setShortMessage(shortMessage,Data.ENC_GSM7BIT);
			request.setScheduleDeliveryTime(scheduleDeliveryTime);
			request.setValidityPeriod(validityPeriod);
			request.setEsmClass(esmClass);
			request.setProtocolId(protocolId);
			request.setPriorityFlag(priorityFlag);
			request.setRegisteredDelivery(registeredDelivery);
			request.setDataCoding(dataCoding);
			request.setSmDefaultMsgId(smDefaultMsgId);

			// send the request

			int count = 1;
			System.out.println();
			count = getParam("How many times to submit this message (load test)", count);
			for (int i = 0; i < count; i++) {
				request.assignSequenceNumber(true);
				System.out.print("#" + i + "  ");
				System.out.println("Submit request " + request.debugString());
				if (asynchronous) {
					session.submit(request);
					System.out.println();
				} else {
					response = session.submit(request);
					System.out.println("Submit response " + response.debugString());
					messageId = response.getMessageId();
				}
			}

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Submit operation failed. " + e);
			System.out.println("Submit operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>SubmitMultiSM</code> class, lets you set
	 * subset of fields of it. This PDU is used to send SMS message
	 * to multiple devices.
	 *
	 * See "SMPP Protocol Specification 3.4, 4.5 SUBMIT_MULTI Operation."
	 * @see Session#submitMulti(SubmitMultiSM)
	 * @see SubmitMultiSM
	 * @see SubmitMultiSMResp
	 */
	private void submitMulti() {
		debug.enter(this, "SMPPTest.submitMulti()");

		try {
			SubmitMultiSM request = new SubmitMultiSM();
			SubmitMultiSMResp response;

			// input values and set some :-)
			serviceType = getParam("Service type", serviceType);
			sourceAddress = getAddress("Source", sourceAddress);
			numberOfDestination = getParam("Number of destinations", numberOfDestination);
			for (int i = 0; i < numberOfDestination; i++) {
				request.addDestAddress(new DestinationAddress(getAddress("Destination", destAddress)));
			}
			replaceIfPresentFlag = getParam("Replace if present flag", replaceIfPresentFlag);
			shortMessage = getParam("The short message", shortMessage);
			scheduleDeliveryTime = getParam("Schdule delivery time", scheduleDeliveryTime);
			validityPeriod = getParam("Validity period", validityPeriod);
			esmClass = getParam("Esm class", esmClass);
			protocolId = getParam("Protocol id", protocolId);
			priorityFlag = getParam("Priority flag", priorityFlag);
			registeredDelivery = getParam("Registered delivery", registeredDelivery);
			dataCoding = getParam("Data encoding", dataCoding);
			smDefaultMsgId = getParam("Sm default msg id", smDefaultMsgId);

			// set other values
			request.setServiceType(serviceType);
			request.setSourceAddr(sourceAddress);
			request.setReplaceIfPresentFlag(replaceIfPresentFlag);
			request.setShortMessage(shortMessage);
			request.setScheduleDeliveryTime(scheduleDeliveryTime);
			request.setValidityPeriod(validityPeriod);
			request.setEsmClass(esmClass);
			request.setProtocolId(protocolId);
			request.setPriorityFlag(priorityFlag);
			request.setRegisteredDelivery(registeredDelivery);
			request.setDataCoding(dataCoding);
			request.setSmDefaultMsgId(smDefaultMsgId);

			// send the request
			System.out.println("Submit Multi request " + request.debugString());
			if (asynchronous) {
				session.submitMulti(request);
			} else {
				response = session.submitMulti(request);
				System.out.println("Submit Multi response " + response.debugString());
				messageId = response.getMessageId();
			}

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Submit Multi operation failed. " + e);
			System.out.println("Submit Multi operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>ReplaceSM</code> class, lets you set
	 * subset of fields of it. This PDU is used to replace certain
	 * attributes of already submitted message providing that you 'remember'
	 * message id of the submitted message. The message id is assigned
	 * by SMSC and is returned to you with the response to the submision
	 * PDU (SubmitSM, DataSM etc.).
	 *
	 * See "SMPP Protocol Specification 3.4, 4.10 REPLACE_SM Operation."
	 * @see Session#replace(ReplaceSM)
	 * @see ReplaceSM
	 * @see ReplaceSMResp
	 */
	private void replace() {
		debug.enter(this, "SMPPTest.replace()");
		try {
			ReplaceSM request = new ReplaceSM();
			ReplaceSMResp response;

			// input values
			messageId = getParam("Message id", messageId);
			sourceAddress = getAddress("Source", sourceAddress);
			shortMessage = getParam("The short message", shortMessage);
			scheduleDeliveryTime = getParam("Schedule delivery time", scheduleDeliveryTime);
			validityPeriod = getParam("Validity period", validityPeriod);
			registeredDelivery = getParam("Registered delivery", registeredDelivery);
			smDefaultMsgId = getParam("Sm default msg id", smDefaultMsgId);

			// set values
			request.setMessageId(messageId);
			request.setSourceAddr(sourceAddress);
			request.setShortMessage(shortMessage);
			request.setScheduleDeliveryTime(scheduleDeliveryTime);
			request.setValidityPeriod(validityPeriod);
			request.setRegisteredDelivery(registeredDelivery);
			request.setSmDefaultMsgId(smDefaultMsgId);

			// send the request
			System.out.println("Replace request " + request.debugString());
			if (asynchronous) {
				session.replace(request);
			} else {
				response = session.replace(request);
				System.out.println("Replace response " + response.debugString());
			}

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Replace operation failed. " + e);
			System.out.println("Replace operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>CancelSM</code> class, lets you set
	 * subset of fields of it. This PDU is used to cancel an already
	 * submitted message. You can only cancel a message which haven't been
	 * delivered to the device yet.
	 *
	 * See "SMPP Protocol Specification 3.4, 4.9 CANCEL_SM Operation."
	 * @see Session#cancel(CancelSM)
	 * @see CancelSM
	 * @see CancelSMResp
	 */
	private void cancel() {
		debug.enter(this, "SMPPTest.cancel()");
		try {
			CancelSM request = new CancelSM();
			CancelSMResp response;

			// input values
			serviceType = getParam("Service type", serviceType);
			messageId = getParam("Message id", messageId);
			sourceAddress = getAddress("Source", sourceAddress);
			destAddress = getAddress("Destination", destAddress);

			// set values
			request.setServiceType(serviceType);
			request.setMessageId(messageId);
			request.setSourceAddr(sourceAddress);
			request.setDestAddr(destAddress);

			// send the request
			System.out.println("Cancel request " + request.debugString());
			if (asynchronous) {
				session.cancel(request);
			} else {
				response = session.cancel(request);
				System.out.println("Cancel response " + response.debugString());
			}

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Cancel operation failed. " + e);
			System.out.println("Cancel operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>DataSM</code> class, lets you set
	 * subset of fields of it. This PDU is an alternative to the <code>SubmitSM</code>
	 * and </code>DeliverSM</code>. It delivers the data to the specified device.
	 *
	 * See "SMPP Protocol Specification 3.4, 4.7 DATA_SM Operation."
	 * @see Session#data(DataSM)
	 * @see DataSM
	 * @see DataSMResp
	 */
	private void data() {
		debug.enter(this, "SMPPTest.data()");

		try {
			DataSM request = new DataSM();
			DataSMResp response;

			// input values
			serviceType = getParam("Service type", serviceType);
			sourceAddress = getAddress("Source", sourceAddress, Data.SM_DATA_ADDR_LEN);
			destAddress = getAddress("Destination", destAddress, Data.SM_DATA_ADDR_LEN);
			esmClass = getParam("Esm class", esmClass);
			registeredDelivery = getParam("Registered delivery", registeredDelivery);
			dataCoding = getParam("Data encoding", dataCoding);

			// set values
			request.setServiceType(serviceType);
			request.setSourceAddr(sourceAddress);
			request.setDestAddr(destAddress);
			request.setEsmClass(esmClass);
			request.setRegisteredDelivery(registeredDelivery);
			request.setDataCoding(dataCoding);

			// send the request
			System.out.println("Data request " + request.debugString());
			if (asynchronous) {
				session.data(request);
			} else {
				response = session.data(request);
				System.out.println("Data response " + response.debugString());
				messageId = response.getMessageId();
			}

		} catch (Exception e) {
			event.write(e, "");
			debug.write("Data operation failed. " + e);
			System.out.println("Data operation failed. " + e);
		} finally {
			debug.exit(this);
		}
	}

	/**
	 * Creates a new instance of <code>QuerySM</code> class, lets you set
	 * subset of fields of it. This PDU is used to fetch information
	 * about status of already submitted message providing that you 'remember'
	 * message id of the submitted message. The message id is assigned
	 * by SMSC and is returned to you with the response to the submision
	 * PDU (SubmitSM, DataSM etc.).
	 *
	 * See "SMPP Protocol Specification 3.4, 4.8 QUERY_SM Operation."
	 * @see Session#query(QuerySM)
	 * @see QuerySM
	 * @see QuerySMResp
	 */
	private void query() {
		debug.enter(this, "SMPPTest.query()");
		try {
			QuerySM request = new QuerySM();
			QuerySMResp response;

			// input values
			messageId = getParam("Message id", messageId);
			sourceAddress = getAddress("Source", sourceAddress);

			// set values
			request.setMessageId(messageId);
			request.setSourceAddr(sourceAddress);

			// send the request
			System.out.println("Query request " + request.debugString());
			if (asynchronous) {
				session.query(request);
			} else {
				response = session.query(request);
				System.out.println("Query response " + response.debugString());