amodemdriver.java

短线收发

				case 9:
					response.append("(tab)");
					break;
				default:
					if (((int) c >= 32) && ((int) c < 128))
					{
						response.append(c);
					}
					else
					{
						response.append("(" + (int) c + ")");
					}
					break;
			}
		}
		return response.toString();
	}

	private class CharQueue
	{
		byte[] buffer;

		int bufferStart, bufferEnd;

		public CharQueue()
		{
			buffer = null;
			bufferStart = 0;
			bufferEnd = 0;
		}

		public synchronized void put(byte c)
		{
			if (buffer == null) buffer = new byte[gateway.getService().S.SERIAL_BUFFER_SIZE];
			buffer[bufferEnd] = c;
			bufferEnd++;
			if (bufferEnd == gateway.getService().S.SERIAL_BUFFER_SIZE) bufferEnd = 0;
			if (gateway.getService().S.DEBUG_QUEUE) gateway.logDebug("IN READER QUEUE : " + (int) c + " / " + (char) c);
			notifyAll();
		}

		public synchronized byte get() throws TimeoutException, InterruptedException
		{
			byte c;
			if (buffer == null) buffer = new byte[gateway.getService().S.SERIAL_BUFFER_SIZE];
			while (true)
			{
				try
				{
					if (bufferStart == bufferEnd) wait(gateway.getService().S.SERIAL_TIMEOUT);
					if (bufferStart == bufferEnd) throw new TimeoutException("No response from device.");
					c = buffer[bufferStart];
					bufferStart++;
					if (bufferStart == gateway.getService().S.SERIAL_BUFFER_SIZE) bufferStart = 0;
					return c;
				}
				catch (InterruptedException e)
				{
					if (gateway.getStarted()) gateway.logWarn("Ignoring InterruptedException in Queue.get().");
					else
					{
						gateway.logWarn("Re-throwing InterruptedException in Queue.get() - should be during shutdown...");
						throw new InterruptedException();
					}
				}
			}
		}

		public synchronized byte peek() throws InterruptedException
		{
			if (buffer == null) buffer = new byte[gateway.getService().S.SERIAL_BUFFER_SIZE];
			while (true)
			{
				try
				{
					if (bufferStart == bufferEnd) wait(gateway.getService().S.SERIAL_TIMEOUT);
					if (bufferStart == bufferEnd) return -1;
					return buffer[bufferStart];
				}
				catch (InterruptedException e)
				{
					if (gateway.getStarted()) gateway.logWarn("Ignoring InterruptedException in Queue.peek().", e);
					else
					{
						gateway.logWarn("Re-throwing InterruptedException in Queue.peek() - should be during shutdown...", e);
						throw new InterruptedException();
					}
				}
			}
		}

		public synchronized String peek(int sizeToRead)
		{
			int i, size;
			StringBuffer result;
			if (buffer == null) buffer = new byte[gateway.getService().S.SERIAL_BUFFER_SIZE];
			size = sizeToRead;
			if (bufferStart == bufferEnd) return "";
			result = new StringBuffer(size);
			i = bufferStart;
			while (size > 0)
			{
				if ((buffer[i] != 0x0a) && (buffer[i] != 0x0d))
				{
					result.append((char) buffer[i]);
					size--;
				}
				i++;
				if (i == gateway.getService().S.SERIAL_BUFFER_SIZE) i = 0;
				if (i == bufferEnd) break;
			}
			return result.toString();
		}

		public synchronized void clear()
		{
			bufferStart = 0;
			bufferEnd = 0;
		}

		public void dump()
		{
			int i;
			i = bufferStart;
			while (i < bufferEnd)
			{
				System.out.println(buffer[i] + " -> " + (char) buffer[i]);
				i++;
			}
		}
	}

	private class ModemReader extends Thread
	{
		private KeepAlive keepAlive;

		public ModemReader(KeepAlive keepAlive)
		{
			this.keepAlive = keepAlive;
			start();
			gateway.logDebug("ModemReader thread started.");
		}

		public void run()
		{
			int c;
			String data;
			while (connected)
			{
				try
				{
					synchronized (SYNC_Reader)
					{
						if (!dataReceived) SYNC_Reader.wait();
						if (!connected) break;
						c = read();
						while (c != -1)
						{
							queue.put((byte) c);
							if (!portHasData()) break;
							c = read();
						}
						dataReceived = false;
					}
					data = queue.peek(6);
					if ((data.indexOf("CMTI") >= 0) || (data.indexOf("CSDI") >= 0) || (data.indexOf("RING") >= 0)) keepAlive.interrupt();
				}
				catch (InterruptedException e)
				{
					if (!connected) break;
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
			gateway.logDebug("ModemReader thread ended.");
		}
	}

	private class KeepAlive extends Thread
	{
		public KeepAlive()
		{
			setPriority(MIN_PRIORITY);
			start();
			gateway.logDebug("ModemDriver: KeepAlive thread started.");
		}

		public void run()
		{
			while (true)
			{
				try
				{
					try
					{
						sleep(gateway.getService().S.SERIAL_KEEPALIVE_INTERVAL);
					}
					catch (InterruptedException e)
					{
					}
					if (!connected) break;
					synchronized (SYNC_Commander)
					{
						if (!connected) break;
						gateway.logDebug("** KeepAlive START **");
						if (!gateway.getATHandler().isAlive()) gateway.setGatewayStatus(GatewayStatuses.RESTART);
						gateway.logDebug("** KeepAlive END **");
					}
				}
				catch (Exception e)
				{
					gateway.logError("ModemDriver: KeepAlive Error.", e);
					gateway.setGatewayStatus(GatewayStatuses.RESTART);
				}
			}
			gateway.logDebug("ModemDriver: KeepAlive thread ended.");
		}
	}

	private class AsyncNotifier extends Thread
	{
		private class Event
		{
			AsyncEvents event;
			String response;
			
			public Event(AsyncEvents event, String response)
			{
				this.event = event;
				this.response = response;
			}
			public String toString()
			{
				return "Event: " + event + " / Response: " + response;
			}
		}
		private org.smslib.Queue eventQueue;
		private Object SYNC;

		public AsyncNotifier()
		{
			SYNC = new Object();
			eventQueue = new org.smslib.Queue();
			setPriority(MIN_PRIORITY);
			start();
			gateway.logDebug("AsyncNotifier thread started.");
		}

		protected void setEvent(AsyncEvents event, String response)
		{
			synchronized (SYNC)
			{
				Event ev = new Event(event, response);
				gateway.logDebug("Storing AsyncEvent: " + ev);
				eventQueue.add(ev);
				SYNC.notify();
			}
		}

		protected String getMemLoc(String indication)
		{
			Pattern p = Pattern.compile("\\+?\"\\S+\"");
			Matcher m = p.matcher(indication);
			if (m.find()) return indication.substring(m.start(), m.end()).replaceAll("\"", "");
			else return "";
		}

		protected int getMemIndex(String indication)
		{
			Pattern p = Pattern.compile("\\+?\\d+");
			Matcher m = p.matcher(indication);
			if (m.find()) return Integer.parseInt(indication.substring(m.start(), m.end()).replaceAll("\"", ""));
			else return -1;
		}

		protected String getOriginator(String indication)
		{
			Pattern p = Pattern.compile("\\+?\"\\S+\"");
			Matcher m = p.matcher(indication);
			if (m.find()) return indication.substring(m.start(), m.end()).replaceAll("\"", "");
			else return "";
		}

		public void run()
		{
			String response;
			Event event;
			while (true)
			{
				try
				{
					synchronized (SYNC)
					{
						event = (Event) eventQueue.get();
						if (event == null)
						{
							SYNC.wait();
							if (!connected) break;
							event = (Event) eventQueue.get();
						}
					}
					synchronized (SYNC_Commander)
					{
						gateway.logDebug("Processing AsyncEvent: " + event);
						if (event.event == AsyncEvents.INBOUNDMESSAGE)
						{
							gateway.logDebug("Inbound message detected!");
							event.event = AsyncEvents.NOTHING;
							response = event.response;
							if (gateway.getInboundNotification() != null) gateway.getInboundNotification().process(gateway.getGatewayId(), MessageTypes.INBOUND, getMemLoc(response), getMemIndex(response));
						}
						else if (event.event == AsyncEvents.INBOUNDSTATUSREPORTMESSAGE)
						{
							gateway.logDebug("Inbound status report message detected!");
							event.event = AsyncEvents.NOTHING;
							response = event.response;
							if (gateway.getInboundNotification() != null) gateway.getInboundNotification().process(gateway.getGatewayId(), MessageTypes.STATUSREPORT, getMemLoc(response), getMemIndex(response));
						}
						else if (event.event == AsyncEvents.INBOUNDCALL)
						{
							gateway.logDebug("Inbound call detected!");
							event.event = AsyncEvents.NOTHING;
							synchronized (SYNC_Commander)
							{		
								try
								{
									gateway.getATHandler().switchToCmdMode();
								}
								catch (Exception e)
								{
								}
								gateway.getModemDriver().write("ATH\r");
								gateway.getModemDriver().getResponse();
								response = event.response;
							}
							if (gateway.getCallNotification() != null) gateway.getCallNotification().process(gateway.getGatewayId(), getOriginator(response));
						}
					}
				}
				catch (InterruptedException e)
				{
					if (!connected) break;
				}
				catch (Exception e)
				{
				}
			}
			gateway.logDebug("AsyncNotifier thread ended.");
		}
	}

	public int getLastError()
	{
		return lastError;
	}

	public String getLastErrorText()
	{
		if (lastError == 0) return "OK";
		else if (lastError == -1) return "Invalid or empty response";
		else if ((lastError / 1000) == 5) return "CME Error " + (lastError % 1000);
		else if ((lastError / 1000) == 6) return "CMS Error " + (lastError % 1000);
		else return "Error: unknown";
	}

	public boolean isOk()
	{
		return (lastError == OK);
	}
}