testgateway.java

使用smslib和GSP modem 发送和接收手机短息

// SMSLib for Java v3
// A Java API library for sending and receiving SMS via a GSM modem
// or other supported gateways.
// Web Site: http://www.smslib.org
//
// Copyright (C) 2002-2008, Thanasis Delenikas, Athens/GREECE.
// SMSLib is distributed under the terms of the Apache License version 2.0
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package org.smslib.test;

import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.smslib.AGateway;
import org.smslib.FailureCauses;
import org.smslib.GatewayException;
import org.smslib.InboundMessage;
import org.smslib.MessageClasses;
import org.smslib.MessageStatuses;
import org.smslib.MessageTypes;
import org.smslib.OutboundMessage;
import org.smslib.TimeoutException;

/**
 * TestGateway - virtual gateway to simulate sending and receiving messages to
 * make testing easier.
 */
public class TestGateway extends AGateway
{
	private int refCounter = 0;

	private int counter = 0;

	/**
	 * After how much sent messages next one should fail setting to 2 makes two
	 * messages sent, and then one failed.
	 */
	protected int failCycle;

	/**
	 * Duration between incomming messages in milliseconds
	 */
	protected int receiveCycle;

	private Thread incommingMessagesThread;

	public TestGateway(String id)
	{
		super(id);
		attributes = GatewayAttributes.SEND;
		this.outbound = true;
		this.inbound = true;
		receiveCycle = 2000;
	}

	/* (non-Javadoc)
	 * @see org.smslib.AGateway#deleteMessage(org.smslib.InboundMessage)
	 */
	public boolean deleteMessage(InboundMessage msg) throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		//NOOP
		return true;
	}

	private InboundMessage generateIncommingMessage()
	{
		incInboundMessageCount();
		return new InboundMessage(new java.util.Date(), "[phone]", "Hello World! #" + getInboundMessageCount(), 0, null);
	}

	/* (non-Javadoc)
	 * @see org.smslib.AGateway#startGateway()
	 */
	public void startGateway() throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		super.startGateway();
		incommingMessagesThread = new Thread(new Runnable()
		{
			// Run thread to fake incomming messages
			public void run()
			{
				while (!incommingMessagesThread.isInterrupted())
				{
					synchronized (incommingMessagesThread)
					{
						try
						{
							incommingMessagesThread.wait(receiveCycle);
						}
						catch (InterruptedException e)
						{
							// NOOP
						}
					}
					if (!incommingMessagesThread.isInterrupted() && getInboundNotification() != null)
					{
						logInfo("Detecting incomming message");
						getInboundNotification().process(gtwId, MessageTypes.INBOUND, null, 0);
					}
				}
			}
		}, "IncommingMessagesThread");
		incommingMessagesThread.start();
	}

	/* (non-Javadoc)
	 * @see org.smslib.AGateway#stopGateway()
	 */
	public void stopGateway() throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		super.stopGateway();
		if (incommingMessagesThread != null)
		{
			synchronized (incommingMessagesThread)
			{
				incommingMessagesThread.interrupt();
			}
		}
	}

	/* (non-Javadoc)
	 * @see org.smslib.AGateway#readMessage(java.lang.String, int)
	 */
	public InboundMessage readMessage(String memLoc, int memIndex) throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		// Return a new generated message 
		return generateIncommingMessage();
	}

	/* (non-Javadoc)
	 * @see org.smslib.AGateway#readMessages(java.util.List, org.smslib.MessageClasses)
	 */
	public void readMessages(List msgList, MessageClasses msgClass) throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		// Return a new generated message
		msgList.add(generateIncommingMessage());
	}

	public boolean sendMessage(OutboundMessage msg) throws TimeoutException, GatewayException, IOException, InterruptedException
	{
		// simulate delay
		Thread.sleep(500);
		counter++;
		if ((failCycle > 0) && (counter >= failCycle))
		{
			msg.setFailureCause(FailureCauses.GATEWAY_FAILURE);
			failCycle = 0;
			return false;
		}
		else
		{
			msg.setDispatchDate(new Date());
			msg.setMessageStatus(MessageStatuses.SENT);
			msg.setRefNo(Integer.toString(++refCounter));
			msg.setGatewayId(getGatewayId());
			logInfo("Send to: " + msg.getRecipient() + " via: " + msg.getGatewayId());
			return true;
		}
	}

	public int getFailCycle()
	{
		return failCycle;
	}

	/**
	 * Set fail cycle value. This is count of successfully sent messages that is
	 * followed by one failed message.
	 * 
	 * @param failCycle
	 *            Set to zero to disable failures.
	 */
	public void setFailCycle(int failCycle)
	{
		this.failCycle = failCycle;
	}
}