public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
InitJ1587DescriptionProvider();
RTProperties cmdLineProps = RTConfig.getCommandLineProperties();
long fault = EncodeFault(cmdLineProps);
Print.sysPrintln("Fault : " + fault + " [0x" + StringTools.toHexString(fault) + "]");
Print.sysPrintln("String: " + GetPropertyString(fault));
Print.sysPrintln("Desc : " + GetFaultDescription(fault, null));
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
/* help */
if (RTConfig.hasProperty(ARG_HELP)) {
_usage();
System.exit(1); // control does not reach here
}
/* extra args */
String extraArgs = RTConfig.getString(ARG_EXTRA, "");
if (!StringTools.isBlank(extraArgs)) {
// Print.logInfo("Extra: " + extraArgs);
RTProperties cfgProps = RTConfig.getConfigFileProperties();
if (extraArgs.indexOf(",") > 0) {
cfgProps.setProperties(extraArgs, ',');
} else {
cfgProps.setProperties(extraArgs);
}
// cfgProps.printProperties("");
}
/* special case "expire" */
String ARG_EXPIRE = "expire";
RTProperties expireRTP = RTConfig.getPropertiesForKey(ARG_EXPIRE, false);
if (expireRTP != null) {
Print.errPrintln("\n'expire' cannot be defined.");
System.exit(1);
}
/* args */
File directory = RTConfig.getFile(ARG_DIR, null);
String templateName =
StringTools.trim(RTConfig.getString(ARG_OPTIONAL, RTConfig.getString(ARG_TEMPLATE, "")));
boolean isOptional = RTConfig.hasProperty(ARG_OPTIONAL);
String packageName = StringTools.trim(RTConfig.getString(ARG_PACKAGE, null));
String outputName = RTConfig.getString(ARG_OUTPUT, "");
boolean overwrite = RTConfig.getBoolean(ARG_OVERWRITE, false);
/* cannot specify "-output=inline" if internal template specified */
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output will be to "stdout"
outputName = "";
} else if (outputName.equalsIgnoreCase("inline")) {
// -- output will be to input file
if (templateName.startsWith(TEMPLATE_)) {
// -- @template not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with internal template");
_usage();
System.exit(1); // control does not reach here
} else if (isOptional) {
// -- optional not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with optional template");
_usage();
System.exit(1); // control does not reach here
} else if (!templateName.startsWith("*")) {
// -- output to input file
outputName = templateName;
}
} else {
// -- output to specified file
if (templateName.startsWith("*")) {
// -- template specifies a file-glob
Print.errPrintln(
"\nError: Cannot specify '-output=FILE' for recursize template specification");
_usage();
System.exit(1); // control does not reach here
}
}
/* template name file? */
if (templateName.startsWith("*")) {
if (isOptional) {
// -- optional not allowed with glob file specification
Print.errPrintln("\nError: Cannot specify optional '-template?=[**/]*.java'");
_usage();
System.exit(1); // control does not reach here
}
} else {
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
if (!file.isFile() && isOptional) {
// -- templateName doesn't exist and is optional
templateName = TEMPLATE_DEFAULT;
}
}
/* random */
Random rand = new Random();
if (!RTConfig.hasProperty("random.16")) {
RTConfig.setString("random.16", "0x" + StringTools.toHexString(rand.nextInt() & 0xFFFF, 16));
}
if (!RTConfig.hasProperty("random.32")) {
RTConfig.setString("random.32", "0x" + StringTools.toHexString(rand.nextInt(), 32));
}
if (!RTConfig.hasProperty("random.64")) {
RTConfig.setString("random.64", "0x" + StringTools.toHexString(rand.nextLong(), 64));
}
/* set current time (subject to change) */
String tzStr = RTConfig.getString("timezone", null);
TimeZone tz =
!StringTools.isBlank(tzStr) ? DateTime.getTimeZone(tzStr) : DateTime.getDefaultTimeZone();
DateTime now = new DateTime(tz);
if (!RTConfig.hasProperty("timetamp")) {
RTConfig.setLong("timestamp", now.getTimeSec());
}
if (!RTConfig.hasProperty("datetime")) {
RTConfig.setString("datetime", now.format("yyyy/MM/dd HH:mm:ss z"));
}
if (!RTConfig.hasProperty("date")) {
RTConfig.setString("date", now.format("yyyy/MM/dd"));
}
if (!RTConfig.hasProperty("time")) {
RTConfig.setString("time", now.format("HH:mm:ss"));
}
if (!RTConfig.hasProperty("timezone")) {
RTConfig.setString("timezone", now.format("z"));
}
/* special case "daysUntil" */
// %{daysUntil=2012:02:20} <== fixed time
String ARG_daysUntil_ = "daysUntil";
Set<String> daysUntil_keys = RTConfig.getPropertyKeys(ARG_daysUntil_, false);
for (String daysUntil_key : daysUntil_keys) {
String daysUntil_key_date = daysUntil_key + ".date";
RTProperties daysUntilRTP = RTConfig.getPropertiesForKey(daysUntil_key, false);
if (daysUntilRTP != null) {
// -- get/update the RTProperties where "daysUntil" is defined
String daysUntil = daysUntilRTP.getString(daysUntil_key, "");
if (StringTools.isBlank(daysUntil)) {
// -- remove keys
daysUntilRTP.removeProperty(daysUntil_key);
daysUntilRTP.removeProperty(daysUntil_key_date);
// Print.sysPrintln(daysUntil_key + " ==> <removed>");
// Print.sysPrintln(daysUntil_key_date + " ==> <removed>");
} else if ((daysUntil.indexOf("/") >= 0) || (daysUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd" to "DD"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (daysUntil.startsWith("'") || daysUntil.startsWith("\"")) {
daysUntil = daysUntil.substring(1); // remove prefixing quote
}
if (daysUntil.endsWith("'") || daysUntil.endsWith("\"")) {
daysUntil = daysUntil.substring(0, daysUntil.length() - 1); // remove trailing quote
}
try {
DateTime nowDT = new DateTime(DateTime.getGMTTimeZone());
DateTime futDT = DateTime.parseArgumentDate(daysUntil, null, true);
long nowDay = DateTime.getDayNumberFromDate(nowDT);
long futDay = DateTime.getDayNumberFromDate(futDT);
long deltaD = futDay - nowDay;
if (deltaD == 0L) {
// -- today
deltaD = 1L; // make it tomorrow
} else if (deltaD < 0L) {
// -- this means that the date has already passed
// deltaD = -1L; // already negative
} else {
deltaD += 1L; // add one more day
}
daysUntilRTP.setString(daysUntil_key, String.valueOf(deltaD));
daysUntilRTP.setString(daysUntil_key_date, futDT.format(DateTime.DEFAULT_DATE_FORMAT));
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + daysUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysUntil, 0L));
daysUntilRTP.setString(
daysUntil_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
}
}
}
/* special case "daysFromNow" */
// %{daysFromNow=30} <== 30 days from now
String ARG_daysFromNow_ = "daysFromNow";
Set<String> daysFromNow_keys = RTConfig.getPropertyKeys(ARG_daysFromNow_, false);
for (String daysFromNow_key : daysFromNow_keys) {
String daysFromNow_key_date = daysFromNow_key + ".date";
RTProperties daysFromNowRTP = RTConfig.getPropertiesForKey(daysFromNow_key, false);
if (daysFromNowRTP != null) {
// -- get/update the RTProperties where "daysFromNow" is defined
String daysFromNow = daysFromNowRTP.getString(daysFromNow_key, "");
if (StringTools.isBlank(daysFromNow)) {
// -- remove keys
daysFromNowRTP.removeProperty(daysFromNow_key);
daysFromNowRTP.removeProperty(daysFromNow_key_date);
// Print.sysPrintln(daysFromNow_key + " ==> <removed>");
// Print.sysPrintln(daysFromNow_key_date + " ==> <removed>");
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysFromNow, 0L));
daysFromNowRTP.setString(daysFromNow_key, String.valueOf(futSec));
daysFromNowRTP.setString(
daysFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysFromNow_key + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key ,"?"));
// Print.sysPrintln(daysFromNow_key_date + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key_date,"?"));
}
}
}
/* special case "secondsUntil" */
// %{secondsUntil_abc=2012:02:20} <== fixed time
// %{secondsUntil_abc=86400} <== relative time (86400 seconds from now)
String ARG_secondsUntil_ = "secondsUntil";
Set<String> secUntil_keys = RTConfig.getPropertyKeys(ARG_secondsUntil_, false);
for (String secUntil_key : secUntil_keys) {
String secUntil_key_date = secUntil_key + ".date";
RTProperties secUntilRTP = RTConfig.getPropertiesForKey(secUntil_key, false);
if (secUntilRTP != null) {
// -- get/update the RTProperties where "secondsUntil" is defined
String secUntil = secUntilRTP.getString(secUntil_key, "");
if (StringTools.isBlank(secUntil)) {
// remove keys
secUntilRTP.removeProperty(secUntil_key);
secUntilRTP.removeProperty(secUntil_key_date);
// Print.sysPrintln(secUntil_key + " ==> <removed>");
// Print.sysPrintln(secUntil_key_date + " ==> <removed>");
} else if ((secUntil.indexOf("/") >= 0) || (secUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd:HH:MM:SS" to "ssssss"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (secUntil.startsWith("'") || secUntil.startsWith("\"")) {
secUntil = secUntil.substring(1); // remove prefixing quote
}
if (secUntil.endsWith("'") || secUntil.endsWith("\"")) {
secUntil = secUntil.substring(0, secUntil.length() - 1); // remove trailing quote
}
try {
long nowSec = DateTime.getCurrentTimeSec();
DateTime futDT = DateTime.parseArgumentDate(secUntil, null, true);
long futSec = futDT.getTimeSec();
long deltaS = futSec - nowSec;
if (deltaS == 0L) {
// -- now
deltaS = 1L; // make it 1 second from now
} else if (deltaS < 0L) {
// -- this means that the time has already passed
// deltaS = -1L; // already negative
} else {
deltaS += 1L; // add one more second
}
secUntilRTP.setString(secUntil_key, String.valueOf(deltaS));
secUntilRTP.setString(secUntil_key_date, futDT.toString());
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + secUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secUntil, 0L);
secUntilRTP.setString(secUntil_key_date, (new DateTime(futSec)).toString());
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
}
}
}
/* special case "secondsFromNow" */
// %{secondsFromNow=30} <== 30 seconds from now
String ARG_secondsFromNow_ = "secondsFromNow";
Set<String> secondsFromNow_keys = RTConfig.getPropertyKeys(ARG_secondsFromNow_, false);
for (String secondsFromNow_key : secondsFromNow_keys) {
String secondsFromNow_key_date = secondsFromNow_key + ".date";
RTProperties secondsFromNowRTP = RTConfig.getPropertiesForKey(secondsFromNow_key, false);
if (secondsFromNowRTP != null) {
// -- get/update the RTProperties where "secondsFromNow" is defined
String secondsFromNow = secondsFromNowRTP.getString(secondsFromNow_key, "");
if (StringTools.isBlank(secondsFromNow)) {
// -- remove keys
secondsFromNowRTP.removeProperty(secondsFromNow_key);
secondsFromNowRTP.removeProperty(secondsFromNow_key_date);
// Print.sysPrintln(secondsFromNow_key + " ==> <removed>");
// Print.sysPrintln(secondsFromNow_key_date + " ==> <removed>");
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secondsFromNow, 0L);
secondsFromNowRTP.setString(secondsFromNow_key, String.valueOf(futSec));
secondsFromNowRTP.setString(
secondsFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(secondsFromNow_key + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key ,"?"));
// Print.sysPrintln(secondsFromNow_key_date + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key_date,"?"));
}
}
}
/* special case "limit" */
String ARG_limit_ = "limit";
Set<String> limit_keys = RTConfig.getPropertyKeys(ARG_limit_, false);
for (String limit_key : limit_keys) {
RTProperties limitRTP = RTConfig.getPropertiesForKey(limit_key, false);
if (limitRTP != null) {
String limit = limitRTP.getString(limit_key, "");
if (StringTools.isBlank(limit)) {
limitRTP.removeProperty(limit_key);
// Print.sysPrintln(limit_key + " ==> <removed>");
} else {
// Print.sysPrintln(limit_key + " ==> " + limit);
}
}
}
/* adjust packageName */
if (packageName.equals(JAVA_PACKAGE)) {
Print.errPrintln(
"\nWarning: 'package' argument cannot equal \"package\" (setting to empty string).");
packageName = "";
}
// --------------------------------------
/* internal template (single pass only) */
if (StringTools.isBlank(templateName) || templateName.startsWith(TEMPLATE_)) {
try {
// -- input source
String inputSource = standardTemplate(templateName, packageName);
if (StringTools.isBlank(inputSource)) {
if (isOptional) {
// -- optional "templateName" not defined, use default template
inputSource = standardTemplate(null, packageName); // non-blank
} else {
throw new IOException("Standard template not found: " + templateName);
}
}
// -- write template output
File outputFile = CompiletimeVars.getOutputFile(directory, outputName, overwrite);
CompiletimeVars.writeOutputSource(inputSource, outputFile);
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
// -- error writin file
Print.errPrintln("\nError writing template: " + ioe.getMessage());
System.exit(1);
}
System.exit(0);
}
// --------------------------------------
/* get input file(s) */
File inputFileArray[] = null;
if (templateName.startsWith("**/*.")) {
// -- all files, in all directories (recursive)
String fileGlob = templateName.substring(3);
File files[] = FileTools.getFiles(directory, fileGlob, true);
inputFileArray = files;
} else if (templateName.startsWith("*.")) {
// -- all files in specified directory
String fileGlob = templateName;
File files[] = FileTools.getFiles(directory, fileGlob, false);
inputFileArray = files;
} else {
// -- single specific file
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
inputFileArray = new File[] {file};
}
/* loop through input files */
boolean singlePass = false;
for (File inputFile : inputFileArray) {
/* file must exist here */
if (!inputFile.isFile()) {
// -- not a file
continue;
}
/* get input source from template file */
String inputSource = CompiletimeVars.readTemplate(inputFile, packageName);
if (StringTools.isBlank(inputSource)) {
// -- inputSource not available?
continue;
}
/* precheck output file */
File outputFile = null;
try {
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output to stdout (multi-pass ok)
} else if (outputName.equalsIgnoreCase("inline")) {
// -- write back to template file (multi-pass ok)
overwrite = true; // assume implied overwrite
outputFile = inputFile;
} else {
// -- output to specified file (single-pass only)
outputFile = getOutputFile(directory, outputName, overwrite);
singlePass = true;
}
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
Print.errPrintln("\nInvalid output file: " + ioe.getMessage());
System.exit(1);
}
/* adjust source and write output */
try {
CompiletimeVars.writeOutputSource(inputSource, outputFile);
if (singlePass) {
break;
}
} catch (IOException ioe) {
Print.errPrintln("\nError writing file: " + ioe.getMessage());
System.exit(1);
}
}
/* success */
System.exit(0);
}
/**
* ** Gets the Description and/or converts the specified binary value to a String ** @param
* errCode The error code ** @param inclDesc True to include the description, false to omit
* ** @param errData The binary payload data ** @param tz A TimeZone used convert any dates
* encountered ** @return The Description and/or value String representation
*/
public static String getStringValue(int errCode, boolean inclDesc, byte errData[], TimeZone tz) {
Payload payload = ((errData != null) && (errData.length > 0)) ? new Payload(errData) : null;
StringBuffer sb = new StringBuffer();
switch (errCode) {
case ERROR_PACKET_HEADER:
if (inclDesc) {
sb.append("Invalid packet header");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_TYPE:
if (inclDesc) {
sb.append("Invalid packet type");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_LENGTH:
if (inclDesc) {
sb.append("Invalid packet length");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_ENCODING:
if (inclDesc) {
sb.append("Unsupported packet encoding");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_PAYLOAD:
if (inclDesc) {
sb.append("Invalid packet payload");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_CHECKSUM:
if (inclDesc) {
sb.append("Invalid checksum");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PACKET_ACK:
if (inclDesc) {
sb.append("Invalid ACL sequence");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PROTOCOL_ERROR:
if (inclDesc) {
sb.append("Protocol error");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String h = StringTools.toHexString(payload.readLong(1, 0L), 8);
String t = StringTools.toHexString(payload.readLong(1, 0L), 8);
sb.append("0x" + h + t);
}
return sb.toString();
case ERROR_PROPERTY_READ_ONLY:
if (inclDesc) {
sb.append("Property is read-only");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String p = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + p);
}
return sb.toString();
case ERROR_PROPERTY_WRITE_ONLY:
if (inclDesc) {
sb.append("Property is write-only");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String p = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + p);
}
return sb.toString();
case ERROR_PROPERTY_INVALID_ID:
if (inclDesc) {
sb.append("Invalid/Unrecognized property key");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String p = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + p);
}
return sb.toString();
case ERROR_PROPERTY_INVALID_VALUE:
if (inclDesc) {
sb.append("Invalid property value");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String p = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + p);
}
return sb.toString();
case ERROR_PROPERTY_UNKNOWN_ERROR:
if (inclDesc) {
sb.append("Unknown property error");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String p = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + p);
}
return sb.toString();
case ERROR_COMMAND_INVALID:
if (inclDesc) {
sb.append("Invalid/Unsupported command");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String c = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("0x" + c);
}
return sb.toString();
case ERROR_COMMAND_ERROR:
if (inclDesc) {
sb.append("Command error");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
String c = StringTools.toHexString(payload.readLong(2, 0L), 16);
String e = StringTools.toHexString(payload.readLong(2, 0L), 16);
sb.append("cmd=0x" + c + ", err=0x" + e);
int dlen = payload.getAvailableReadLength();
if (dlen > 0) {
String d = StringTools.toHexString(payload.readBytes(dlen));
sb.append(", data=0x" + d);
}
}
return sb.toString();
case ERROR_UPLOAD_TYPE:
if (inclDesc) {
sb.append("Invalid upload type");
}
return sb.toString();
case ERROR_UPLOAD_PACKET:
if (inclDesc) {
sb.append("Invalid upload packet");
}
return sb.toString();
case ERROR_UPLOAD_LENGTH:
if (inclDesc) {
sb.append("Invalid upload length");
}
return sb.toString();
case ERROR_UPLOAD_OFFSET_OVERLAP:
if (inclDesc) {
sb.append("Upload offset overlap");
}
return sb.toString();
case ERROR_UPLOAD_OFFSET_GAP:
if (inclDesc) {
sb.append("Upload offset gap");
}
return sb.toString();
case ERROR_UPLOAD_OFFSET_OVERFLOW:
if (inclDesc) {
sb.append("Upload offset overflow");
}
return sb.toString();
case ERROR_UPLOAD_FILE_NAME:
if (inclDesc) {
sb.append("Invalid uploaded filename");
}
return sb.toString();
case ERROR_UPLOAD_CHECKSUM:
if (inclDesc) {
sb.append("Invalid uploaded checksum");
}
return sb.toString();
case ERROR_UPLOAD_SAVE:
if (inclDesc) {
sb.append("Unable to save uploaded file");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
int dlen = payload.getAvailableReadLength();
String d = StringTools.toHexString(payload.readBytes(dlen));
sb.append("0x" + d);
}
return sb.toString();
case ERROR_UPLOAD_HOST:
if (inclDesc) {
sb.append("Invalid/unspecified upload host:port");
}
return sb.toString();
case ERROR_UPLOAD_SERVER_ERROR:
if (inclDesc) {
sb.append("Server indicated upload error");
}
return sb.toString();
case ERROR_GPS_EXPIRED:
if (inclDesc) {
sb.append("GPS Expired");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
long lastFix = payload.readLong(4, 0L);
sb.append("lastFix=");
if (lastFix <= 0L) {
sb.append("never"); // i18n
} else if (tz != null) {
DateTime dt = new DateTime(lastFix, tz);
sb.append(dt.format("yyyy/MM/dd,HH:mm:ss")); // i18n
} else {
sb.append(lastFix);
}
}
return sb.toString();
case ERROR_GPS_FAILURE:
if (inclDesc) {
sb.append("GPS Failure");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
long lastFix = payload.readLong(4, 0L);
sb.append("lastFix=");
if (lastFix <= 0L) {
sb.append("never"); // i18n
} else if (tz != null) {
DateTime dt = new DateTime(lastFix, tz);
sb.append(dt.format("yyyy/MM/dd,HH:mm:ss")); // i18n
} else {
sb.append(lastFix);
}
int dlen = payload.getAvailableReadLength();
if (dlen > 0) {
String d = StringTools.toHexString(payload.readBytes(dlen));
sb.append(" data=0x" + d);
}
}
return sb.toString();
case ERROR_OUT_OF_MEMORY:
if (inclDesc) {
sb.append("Out-Of-Memory error");
}
return sb.toString();
}
/* internal error */
if ((errCode >= ERROR_INTERNAL_ERROR_00) && (errCode <= ERROR_INTERNAL_ERROR_0F)) {
if (inclDesc) {
sb.append("Internal error");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
int dlen = payload.getAvailableReadLength();
String d = StringTools.toHexString(payload.readBytes(dlen));
sb.append("0x" + d);
}
return sb.toString();
}
/* unknown */
if (inclDesc) {
sb.append("Unknown[0x").append(StringTools.toHexString(errCode, 16)).append("]");
if (payload != null) {
sb.append(": ");
}
}
if (payload != null) {
int dlen = payload.getAvailableReadLength();
String d = StringTools.toHexString(payload.readBytes(dlen));
sb.append("0x" + d);
}
return sb.toString();
}
public boolean insertEventData() {
/* valid device? */
if (this.device == null) {
return false;
}
/* debug message */
if (RTConfig.isDebugMode()) {
Print.logDebug("Inserting EventData ...\n" + this.toString());
}
/* EventData key */
String acctID = this.device.getAccountID();
String devID = this.device.getDeviceID();
long fixtime = this.getTimestamp();
int statusCode = this.getStatusCode();
EventData.Key evKey = new EventData.Key(acctID, devID, fixtime, statusCode);
EventData evdb = evKey.getDBRecord();
/* set EventData field values */
if (USE_EVENTDATA_SETVALUE) {
for (Object fldn : this.fieldValues.getPropertyKeys()) {
if (fldn.equals(EventData.FLD_timestamp)) {
continue; // already set above
} else if (fldn.equals(EventData.FLD_statusCode)) {
continue; // already set above
}
Object fldv = this.fieldValues.getProperty(fldn, null);
if (fldv != null) {
evdb.setValue((String) fldn, fldv); // attempts to use "setter" methods
}
}
} else {
if (this.hasLatitude()) {
evdb.setLatitude(this.getLatitude());
}
if (this.hasLongitude()) {
evdb.setLongitude(this.getLongitude());
}
if (this.hasGpsAge()) {
evdb.setGpsAge(this.getGpsAge());
}
if (this.hasHDOP()) {
evdb.setHDOP(this.getHDOP());
}
if (this.hasSatelliteCount()) {
evdb.setSatelliteCount(this.getSatelliteCount());
}
if (this.hasSpeedKPH()) {
evdb.setSpeedKPH(this.getSpeedKPH());
}
if (this.hasHeading()) {
evdb.setHeading(this.getHeading());
}
if (this.hasAltitude()) {
evdb.setAltitude(this.getAltitude());
}
if (this.hasInputMask()) {
evdb.setInputMask(this.getInputMask());
}
if (this.hasBatteryLevel()) {
evdb.setBatteryLevel(this.getBatteryLevel());
}
if (this.hasSignalStrength()) {
evdb.setSignalStrength(this.getSignalStrength());
}
if (this.hasOdometerKM()) {
evdb.setOdometerKM(this.getOdometerKM());
}
if (this.hasEngineHours()) {
evdb.setEngineHours(this.getEngineHours());
}
if (this.hasPtoHours()) {
evdb.setPtoHours(this.getPtoHours());
}
if (this.hasFuelTotal()) {
evdb.setFuelTotal(this.getFuelTotal());
}
if (this.hasGeozoneID()) {
evdb.setGeozoneID(this.getGeozoneID());
}
}
/* other fields (if available) */
if (this.otherValues != null) {
for (String fldn : this.otherValues.keySet()) {
if (fldn.equals(EventData.FLD_timestamp)) {
continue;
} else if (fldn.equals(EventData.FLD_statusCode)) {
continue;
}
Object fldv = this.otherValues.get(fldn);
if (fldv != null) {
evdb.setValue(fldn, fldv); // attempts to use "setter" methods
}
}
}
/* insert event */
// this will display an error if it was unable to store the event
Print.logInfo(
"Event : [0x"
+ StringTools.toHexString(statusCode, 16)
+ "] "
+ StatusCodes.GetDescription(statusCode, null));
this.device.insertEventData(
evdb); // FLD_lastValidLatitude,FLD_lastValidLongitude,FLD_lastGPSTimestamp,FLD_lastOdometerKM
this.eventTotalCount++;
return true;
}
public String toString() {
return "0x" + StringTools.toHexString(this.getFaultCode());
}