modemdriver.java

华为编程开发规范与案例, 华为编程开发规范与案例,华为编程开发规范与案例

					return true;
				case -1:
					gateway.getLogger().info("GSM: Invalid CREG response.");
					throw new OopsException("GSM: Invalid CREG response.");
			}
			Thread.sleep(2000);
		}
	}

	private String formatLog(StringBuffer s)
	{
		StringBuffer response = new StringBuffer();
		int i;

		for (i = 0; i < s.length(); i++)
		{
			switch (s.charAt(i))
			{
				case 13:
					response.append("(cr)");
					break;
				case 10:
					response.append("(lf)");
					break;
				case 9:
					response.append("(tab)");
					break;
				default:
					response.append("(" + (int) s.charAt(i) + ")");
					break;
			}
		}
		response.append("  Text:[");
		for (i = 0; i < s.length(); i++)
		{
			switch (s.charAt(i))
			{
				case 13:
					response.append("(cr)");
					break;
				case 10:
					response.append("(lf)");
					break;
				case 9:
					response.append("(tab)");
					break;
				default:
					response.append(s.charAt(i));
					break;
			}
		}
		response.append("]");
		return response.toString();
	}

	private class CharQueue
	{
		byte[] buffer;

		int bufferStart, bufferEnd;

		public CharQueue()
		{
			buffer = new byte[BUFFER_SIZE];
			bufferStart = 0;
			bufferEnd = 0;
		}

		public synchronized void put(byte c)
		{
			buffer[bufferEnd] = c;
			bufferEnd++;
			if (bufferEnd == BUFFER_SIZE) bufferEnd = 0;
			if(ENABLE_QUEUE_DEBUG) gateway.getLogger().debug("IN READER QUEUE : " + (int) c + " / " + (char) c);
			notifyAll();
		}

		public synchronized byte get() throws Exception
		{
			byte c;

			if (bufferStart == bufferEnd) wait(RECEIVE_TIMEOUT);
			if (bufferStart == bufferEnd) throw new org.smslib.NoResponseException();
			c = buffer[bufferStart];
			bufferStart++;
			if (bufferStart == BUFFER_SIZE) bufferStart = 0;
			return c;
		}

		public synchronized byte peek() throws Exception
		{
			if (bufferStart == bufferEnd) wait(RECEIVE_TIMEOUT);
			if (bufferStart == bufferEnd) return -1;
			return buffer[bufferStart];
		}

		public synchronized String peek(int sizeToRead) throws Exception
		{
			int i, size;
			StringBuffer result;

			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 == 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
	{
		public ModemReader()
		{
			start();
			gateway.getLogger().debug("ModemReader thread started.");
		}

		public void run()
		{
			int c;

			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;
					}
				}
				catch (InterruptedException e)
				{
					if (!connected) break;
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
			gateway.getLogger().debug("ModemReader thread ended.");
		}
	}

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

		public void run()
		{
			while (true)
			{
				try
				{
					sleep(5000);
					if (!connected) break;
					synchronized (SYNC_Commander)
					{
						gateway.getLogger().debug("ModemDriver: Pinging modem...");
						gateway.getATHandler().isAlive();
					}
				}
				catch (InterruptedException e)
				{
					if (!connected) break;
				}
				catch (Exception e)
				{
				}
			}
			gateway.getLogger().debug("ModemDriver: KeepAlive thread ended.");
		}
	}

	private class AsyncNotifier extends Thread
	{
		private AsyncEvents event;

		private Object SYNC;

		public AsyncNotifier()
		{
			SYNC = new Object();
			setPriority(MIN_PRIORITY);
			start();
			gateway.getLogger().debug("AsyncNotifier thread started.");
		}

		protected void setEvent(AsyncEvents event)
		{
			synchronized (SYNC)
			{
				this.event = event;
				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;

			while (true)
			{
				try
				{
					synchronized (SYNC)
					{
						SYNC.wait();
						if (!connected) break;
						switch (event)
						{
							case InboundMessage:
								event = AsyncEvents.Nothing;
								response = gateway.getATHandler().getAsyncEventResponse(AsyncEvents.InboundMessage);
								if (gateway.getInboundNotification() != null) gateway.getInboundNotification().received(gateway.gatewayId, Message.MessageType.INBOUND, getMemLoc(response), getMemIndex(response));
								break;
							case InboundStatusReportMessage:
								event = AsyncEvents.Nothing;
								response = gateway.getATHandler().getAsyncEventResponse(AsyncEvents.InboundStatusReportMessage);
								if (gateway.getInboundNotification() != null) gateway.getInboundNotification().received(gateway.gatewayId, Message.MessageType.STATUSREPORT, getMemLoc(response), getMemIndex(response));
								break;
							case InboundCall:
								event = AsyncEvents.Nothing;
								response = gateway.getATHandler().getAsyncEventResponse(AsyncEvents.InboundCall);
								if (gateway.getCallNotification() != null) gateway.getCallNotification().received(gateway.gatewayId, getOriginator(response));
								break;
						}
					}
				}
				catch (InterruptedException e)
				{
					if (!connected) break;
				}
				catch (Exception e)
				{
				}
			}
			gateway.getLogger().debug("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";
		}
	}

}