<!-- USB support -->
  <uses-feature android:name="android.hardware.usb.host" />

  <!-- Don't require touchscreen -->
  <uses-feature android:name="android.hardware.touchscreen" required="false" />

  <!-- Don't require NFC -->
  <uses-feature android:name="android.hardware.nfc" required="false" />

  <!-- Disable screen compatibility modes -->
  <supports-screens android:smallScreens="true"
                    android:normalScreens="true"
                    android:largeScreens="true"
                    android:xlargeScreens="true" />

  <!-- Permissions: allow writing to external storage etc. -->

    <uses-permission android:name="android.permission.SEND_SMS" />
  -->
  <!-- Uncomment this for "borg broadcast register android.provider.telephony.SMS_RECEIVED ..."
    <uses-permission android:name="android.permission.RECEIVE_SMS" />
  -->
  <uses-permission android:name="com.android.launcher.permission.INSTALL_SHORTCUT" />
  <uses-permission android:name="com.android.launcher.permission.UNINSTALL_SHORTCUT" />
  <uses-permission android:name="android.permission.NFC" />
</manifest>

static jmethodID M_AW_cameraGetImage = NULL;
static jmethodID M_AW_cameraGetState = NULL;
static jmethodID M_AW_cameraTakePicture = NULL;
static jmethodID M_AW_cameraGetPicture = NULL;
static jmethodID M_AW_checkPermission = NULL;
static jmethodID M_AW_osenvGetString = NULL;
static jmethodID M_AW_osenvGetFlag = NULL;
static jmethodID M_AW_ndefRead = NULL;
static jmethodID M_AW_ndefWrite = NULL;
static jmethodID M_AW_ndefFormat = NULL;

/* List of tk.tcl.wish.AndroWish static method descriptions */

static const struct {
    const char *name;
    const char *sig;
    jmethodID *midp;

	"(ILjava/lang/String;)Ljava/lang/String;",
	&M_AW_osenvGetString
    },
    {
	"osenvGetFlag",
	"(I)I",
	&M_AW_osenvGetFlag
    },
    {
	"ndefRead",
	"(Ljava/lang/String;I)[Ljava/lang/String;",
	&M_AW_ndefRead
    },
    {
	"ndefWrite",
	"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
	&M_AW_ndefWrite
    },
    {
	"ndefFormat",
	"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
	&M_AW_ndefFormat
    }
};

/* List of tk.tcl.wish.WrappedCursor static method descriptions */

static const struct {
    const char *name;

    int ret, command;
    static CONST char *CONST borgCmds[] = {
	"activity", "alarm", "beep", "bluetooth",
	"brightness", "broadcast", "camera", "cancel",
	"checkpermission",
	"content", "displaymetrics", "endspeak", "isspeaking",
	"keyboardinfo", "locale", "location", "log",
	"ndefformat", "ndefread", "ndefwrite", "networkinfo",
	"notification", "onintent", "osbuildinfo",
	"osenvironment", "packageinfo", "phoneinfo", "providerinfo",
	"queryactivities", "querybroadcastreceivers",
	"queryconsts", "queryfeatures", "queryfields",
	"queryservices",
	"screenorientation", "sendsms", "sensor", "shortcut",
	"speak", "speechrecognition", "spinner", "stopspeak",
	"systemproperties", "systemui", "tetherinfo", "toast",
	"trace", "usbdevices", "usbpermission", "vibrate",
	"withdraw", NULL
    };
    enum borgCommands {
	BORG_activity, BORG_alarm, BORG_beep, BORG_bluetooth,
	BORG_brightness, BORG_broadcast, BORG_camera, BORG_cancel,
	BORG_checkpermission,
	BORG_content, BORG_displaymetrics, BORG_endspeak, BORG_isspeaking,
	BORG_keyboardinfo, BORG_locale, BORG_location, BORG_log,
	BORG_ndefformat, BORG_ndefread, BORG_ndefwrite, BORG_networkinfo,
	BORG_notification, BORG_onintent, BORG_osbuildinfo,
	BORG_osenvironment, BORG_packageinfo, BORG_phoneinfo, BORG_providerinfo,
	BORG_queryactivities, BORG_querybroadcastreceivers,
	BORG_queryconsts, BORG_queryfeatures, BORG_queryfields,
	BORG_queryservices,
	BORG_screenorientation, BORG_sendsms, BORG_sensor, BORG_shortcut,
	BORG_speak, BORG_speechrecognition, BORG_spinner, BORG_stopspeak,

    case BORG_usbdevices: {
	int ext = 0;

	if (objc > 3) {
	    Tcl_WrongNumArgs(interp, 2, objv, "?extended?");
	    return TCL_ERROR;
	}
	if ((objc > 2) &&
	    (Tcl_GetBooleanFromObj(interp, objv[2], &ext) != TCL_OK)) {
	    return TCL_ERROR;
	}
	return UsbDevices(interp, ext);
    }

    case BORG_usbpermission: {
	int ask = 0;

	if ((objc < 3) || (objc > 4)) {
	    Tcl_WrongNumArgs(interp, 2, objv, "device ?ask?");
	    return TCL_ERROR;
	}
	if ((objc > 3) &&
	    (Tcl_GetBooleanFromObj(interp, objv[3], &ask) != TCL_OK)) {
	    return TCL_ERROR;
	}
	return UsbPermission(interp, Tcl_GetString(objv[2]), ask);
    }

    case BORG_toast: {

	    OSENV_isexternalstorageremovable,
	    OSENV_rootdir
	};
	int op;
	JNIEnv *env = GetJNIEnv();
	jstring jstr = NULL, jret = NULL;

	if (env == NULL) {
	    Tcl_SetResult(interp, "no JNIEnv", TCL_STATIC);
	    return TCL_ERROR;
	}
	if ((objc < 3) || (objc > 4)) {
	    Tcl_WrongNumArgs(interp, 2, objv, "datadir|rootdir|... ?path?");
	    return TCL_ERROR;
	}
	if (Tcl_GetIndexFromObj(interp, objv[2], osenvCmds, "option",
				0, &command) != TCL_OK) {
	    return TCL_ERROR;

	case OSENV_isexternalstorageremovable:
	    op = 1;
	oseGetFlag:
	    op = (*env)->CallStaticIntMethod(env, jactivity,
					     M_AW_osenvGetFlag, op);
	    Tcl_SetObjResult(interp, Tcl_NewIntObj(op));
	    break;
	}
	if (jstr != NULL) {
	    (*env)->DeleteLocalRef(env, jstr);
	}
	return ret;
    }

    case BORG_ndefread: {
	JNIEnv *env = GetJNIEnv();
	jstring jtag = NULL;
	jobjectArray jret = NULL, jstr;
	int len, cached = 0;

	if (env == NULL) {
	    Tcl_SetResult(interp, "no JNIEnv", TCL_STATIC);
	    return TCL_ERROR;
	}
	if ((objc < 3) || (objc > 4)) {
	    Tcl_WrongNumArgs(interp, 2, objv, "tag ?cached?");
	    return TCL_ERROR;
	}
	if ((objc > 3) &&
	    (Tcl_GetBooleanFromObj(interp, objv[3], &cached) != TCL_OK)) {
	    return TCL_ERROR;
	}
	jtag = (*env)->NewStringUTF(env, Tcl_GetString(objv[2]));
	jret = (*env)->CallStaticObjectMethod(env, jactivity,
					      M_AW_ndefRead, jtag,
					      (jint) cached);
	(*env)->ExceptionClear(env);
	(*env)->DeleteLocalRef(env, jtag);
	if (jret == NULL) {
	    Tcl_SetResult(interp, "unknown error", TCL_STATIC);
	    return TCL_ERROR;
	}
	len = (*env)->GetArrayLength(env, jret);
	if (len < 2) {
	    (*env)->DeleteLocalRef(env, jret);
	    Tcl_SetResult(interp, "unknown error", TCL_STATIC);
	    return TCL_ERROR;
	}
	jstr = (*env)->GetObjectArrayElement(env, jret, 0);
	if (jstr != NULL) {
	    const char *str = (*env)->GetStringUTFChars(env, jstr, 0);

	    Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
	    (*env)->ReleaseStringUTFChars(env, jstr, str);
	    (*env)->DeleteLocalRef(env, jstr);
	    (*env)->DeleteLocalRef(env, jret);
	    return TCL_ERROR;
	}
	jstr = (*env)->GetObjectArrayElement(env, jret, 1);
	if (jstr != NULL) {
	    const char *str = (*env)->GetStringUTFChars(env, jstr, 0);

	    Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
	    (*env)->ReleaseStringUTFChars(env, jstr, str);
	    (*env)->DeleteLocalRef(env, jstr);
	} else {
	    Tcl_SetObjResult(interp, Tcl_NewObj());
	}
	(*env)->DeleteLocalRef(env, jret);
	return TCL_OK;
    }

    case BORG_ndefwrite:
    case BORG_ndefformat: {
	JNIEnv *env = GetJNIEnv();
	jstring jtag = NULL, jdata = NULL, jret = NULL;

	if (env == NULL) {
	    Tcl_SetResult(interp, "no JNIEnv", TCL_STATIC);
	    return TCL_ERROR;
	}
	if (objc != 4) {
	    Tcl_WrongNumArgs(interp, 2, objv, "tag ndefdata");
	    return TCL_ERROR;
	}
	jtag = (*env)->NewStringUTF(env, Tcl_GetString(objv[2]));
	jdata = (*env)->NewStringUTF(env, Tcl_GetString(objv[3]));
	jret = (*env)->CallStaticObjectMethod(env, jactivity,
					      (command == BORG_ndefformat) ?
					      M_AW_ndefFormat : M_AW_ndefWrite,
					      jtag, jdata);
	(*env)->ExceptionClear(env);
	(*env)->DeleteLocalRef(env, jtag);
	(*env)->DeleteLocalRef(env, jdata);
	if (jret != NULL) {
	    const char *str = (*env)->GetStringUTFChars(env, jret, 0);

	    Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
	    (*env)->ReleaseStringUTFChars(env, jret, str);
	    (*env)->DeleteLocalRef(env, jret);
	    return TCL_ERROR;
	}
	return TCL_OK;
    }

    }

    return TCL_OK;
}

JNIEnv *

import android.util.*;
import android.bluetooth.*;
import android.widget.*;
import android.support.v4.app.NotificationCompat;
import android.hardware.*;
import android.hardware.usb.*;
import android.telephony.*;
import android.nfc.*;
import android.nfc.tech.*;

public class AndroWish extends SDLActivity implements LocationListener {

    static final String TAG = "AndroWish";

    protected static AndroWish mSingleton;
    protected static PackageManager mPackageManager;

    protected static NmeaInfo mNmeaInfo;
    protected static TelephonyManager mPhoneManager;
    protected static PSListener mPSListener;
    protected static Map<String, BCRecvr> mBCRecvrs;
    protected static ImageCapture mCamera;
    protected static BroadcastReceiver mUsbRecvr;
    protected static Map<String, UsbDeviceConnection> mUsbHold;
    protected static NfcAdapter mNfcAdapter;
    protected static Tag mNfcTag;

    /*
     * Callback on application startup
     */

    @Override
    public void onCreate(Bundle savedInstanceData) {

			    }
			}
		    }
		}
	    };
	    registerReceiver(mUsbRecvr, filter);
	}
	if (hasPerm(android.Manifest.permission.NFC)) {
	    NfcManager manager =
		(NfcManager) getSystemService(Context.NFC_SERVICE);
	    mNfcAdapter = manager.getDefaultAdapter();
	} else {
	    mNfcAdapter = null;
	}
	mNfcTag = null;
    }

    /*
     * Tear down everything
     */

    @Override

	if (mUsbHold != null) {
	    for (final UsbDeviceConnection c : mUsbHold.values()) {
		c.close();
	    }
	    mUsbHold.clear();
	    mUsbHold = null;
	}
	if (mNfcAdapter != null) {
	    mNfcAdapter.disableForegroundDispatch(this);
	}
	mNfcTag = null;
    }

    /*
     * Find out if OpenGL ES >= 2.x is available.
     */

    private static int getGLESVersion(Context context) {

	mSensors.pause();
	if (mPSListener != null) {
	    mPhoneManager.listen(mPSListener, PhoneStateListener.LISTEN_NONE);
	}
	if (mCamera != null) {
	    mCamera.onPause();
	}
	if (mNfcAdapter != null) {
	    mNfcAdapter.disableForegroundDispatch(this);
	}
	mNfcTag = null;
    }

    @Override
    public void onResume() {
	super.onResume();
	mSensors.resume();
	if (mPSListener != null) {

	    }
	}
	if (trigger) {
	    mSingleton.nativeTriggerKeyboard();
	}
	if (mCamera != null) {
	    mCamera.onResume();
	}
	if (mNfcAdapter != null) {
	    PendingIntent pi =
		PendingIntent.getBroadcast(getContext(), 0,
					   new Intent("tk.tcl.wish.nfc"), 0);
	    /*
	     * This should be sufficient but doesn't work, unfortunately:
	     *
	     *   mNfcAdapter.enableForegroundDispatch(this, pi, null, null);
	     *
	     * thus use filters for both intent and tech.
	     */

	    IntentFilter ndef =
		new IntentFilter(NfcAdapter.ACTION_NDEF_DISCOVERED);
	    IntentFilter[] filt = new IntentFilter[] { ndef };
	    String[][] techs = new String[][] {
		new String[] { Ndef.class.getName() },
		new String[] { NdefFormatable.class.getName() }
	    };
	    mNfcAdapter.enableForegroundDispatch(this, pi, filt, techs);
	    mNfcTag = null;
	}
    }

    /*
     * Configuration (e.g. keyboard) has changed
     */

		ret[k] = encodeLongList((long []) obj);
	    } else if (obj instanceof boolean[]) {
		ret[k] = encodeBoolList((boolean []) obj);
	    } else if (obj instanceof char[]) {
		ret[k] = encodeCharList((char []) obj);
	    } else if (obj instanceof Boolean) {
		ret[k] = ((Boolean) obj).booleanValue() ? "1" : "0";
	    } else if ((obj instanceof Parcelable[]) &&
		       key.equals(NfcAdapter.EXTRA_NDEF_MESSAGES)) {
		ArrayList<byte[]> al = new ArrayList<byte[]>();
		Parcelable[] pa = (Parcelable[]) obj;
		for (int n = 0; n < pa.length; n++) {
		    NdefMessage msg = (NdefMessage) pa[n];
		    byte[] ba;
		    if (msg != null) {
			ba = msg.toByteArray();
		    } else {
			ba = new byte[0];
		    }
		    al.add(ba);
		}
		ret[k] = encodeToList(al);
	    } else {
		ret[k] = obj.toString();
	    }
	    k++;
	}
	if (add != null) {
	    for (int i = 0; i < add.length; i++) {

     */

    public static int getResourceId(String name, String res) {
	try {
	    return mSingleton.getResources().getIdentifier(name, res, mSingleton.getPackageName());
	} catch (Exception e) {
	    return -1;
	}
    }

    /*
     * Callback to deal with activity results
     */

    @Override

	    if (i != 0) {
		r.append(" ");
	    }
	    if (obj == null) {
		r.append("{}");
	    } else if (obj instanceof String) {
		r.append(toElement((String) obj));
	    } else if (obj instanceof byte[]) {
		r.append(Base64.encodeToString((byte[]) obj, Base64.DEFAULT));
	    } else {
		r.append(toElement(obj.toString()));
	    }
	}
	return r.toString();
    }

	String uristr = i.getDataString();
	String type = i.getType();
	String[] cats = null;
	String[] args = null;
	if (i.getCategories() != null) {
	    cats = formatCategories(i.getCategories());
	}
	Bundle extras = i.getExtras();
	if (extras != null) {
	    String addargs[] = null;
	    if (action.equals("android.provider.Telephony.SMS_RECEIVED")) {


		Object[] pdus = (Object[]) extras.get("pdus");
		if (pdus.length > 0) {
		    SmsMessage[] msgs = new SmsMessage[pdus.length];
		    StringBuilder sb = new StringBuilder();
		    for (int k = 0; k < pdus.length; k++) {
			msgs[k] =
			    SmsMessage.createFromPdu((byte[]) pdus[k]);
			sb.append(msgs[k].getMessageBody());
		    }
		    addargs = new String[4];
		    addargs[0] = "phone_number";
		    addargs[1] = msgs[0].getOriginatingAddress();
		    addargs[2] = "sms_text";
		    addargs[3] = sb.toString();
		}
            } else if (action.equals("tk.tcl.wish.nfc")) {
		if (extras.get(NfcAdapter.EXTRA_TAG) != null) {
		    mNfcTag = (Tag) extras.get(NfcAdapter.EXTRA_TAG);
		}
	    }
	    args = formatBundle(extras, addargs);
	}
	Log.v(TAG, "nativeBroadcastCallback: " + retcode + "," + action +
	      "," + uristr + "," + type + "," + cats + "," + args);
	nativeBroadcastCallback(retcode, action, uristr, type, cats, args);
    }

    /*

		if (uristr != null) {
		    if (uristr.length() == 0) {
			return;
		    }
		    ringuri = Uri.parse(uristr);
		}
		if (ringuri == null) {
		    ringuri =
			RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
		}
		Ringtone tone =
		    RingtoneManager.getRingtone(mSingleton.getBaseContext(),
						ringuri);
		if ((tone != null) && (!tone.isPlaying())) {
		    tone.play();

	    if (android.os.Build.VERSION.SDK_INT < 14) {
		toRun.putExtra("arg", arg);
	    } else {
		toRun.setData(Uri.parse(arg));
	    }
	}
	if (icon != null) {
	    byte b[];
	    try {
		b = Base64.decode(icon, Base64.DEFAULT);
	    } catch (Exception be) {
		b = null;
	    }
	    if ((b != null) && (b.length > 0)) {
		iconBitmap = BitmapFactory.decodeByteArray(b, 0, b.length);
	    }
	}
	switch (op) {
	case 0:		/* add */
	    shortcut = new Intent("com.android.launcher.action.INSTALL_SHORTCUT");

		break;
	    }
	    nb = new NotificationCompat.Builder(mSingleton.getContext());
	    nb.setSmallIcon(R.drawable.icon);
	    nb.setContentTitle(title);
	    nb.setContentText(text);
	    if (icon != null) {
		byte b[];
		try {
		    b = Base64.decode(icon, Base64.DEFAULT);
		} catch (Exception be) {
		    b = null;
		}
		if ((b != null) && (b.length > 0)) {
		    Bitmap iconBitmap =
			BitmapFactory.decodeByteArray(b, 0, b.length);
		    nb.setLargeIcon(iconBitmap);
		}
	    }
	    nb.setContentIntent(pi);

	    break;
	case 1:
	    b = android.os.Environment.isExternalStorageRemovable();
	    break;
	}
	return b ? 1 : 0;
    }

    /*
     * NFC related: read/write NDEF content to tag.
     */

    public static String[] ndefRead(String tagstr, int cached) {
	String result[] = new String[2];
	Tag tag = mNfcTag;
	byte tb[] = null;
	result[0] = "unknown error";
	result[1] = null;
	try {
	    tb = Base64.decode(tagstr, Base64.DEFAULT);
	} catch (Exception te) {
	    tb = null;
	}
	if (tb == null) {
	    result[0] = "tag invalid";
	    Log.e(TAG, "ndefRead: " + result[0]);
	    return result;
	}
	if (tag == null) {
	    result[0] = "no current tag";
	    Log.e(TAG, "nfcRead: " + result[0]);
	    return result;
	}
	if (!Arrays.equals(tag.getId(), tb)) {
	    result[0] = "wrong tag id";
	    Log.e(TAG, "nfcRead: tag not current: " + tagstr + " expecting " +
		  Base64.encodeToString(tag.getId(), Base64.DEFAULT));
	    return result;
	}
	try {
	    Ndef ndef = Ndef.get(tag);
	    NdefMessage ndmsg;
	    if (cached == 0) {
		ndef.connect();
		ndmsg = ndef.getNdefMessage();
		ndef.close();
	    } else {
		ndmsg = ndef.getCachedNdefMessage();
	    }
	    if (ndmsg != null) {
		result[1] =
		    Base64.encodeToString(ndmsg.toByteArray(), Base64.DEFAULT);
	    }
	} catch (Exception e) {
	    result[0] = "read error";
	    result[1] = null;
	    Log.e(TAG, "nfcRead: exception: " + e.toString());
	    return result;
	}
	result[0] = null;
	return result;
    }

    public static String ndefWrite(String tagstr, String msg) {
	Tag tag = mNfcTag;
	byte tb[];
	try {
	    tb = Base64.decode(tagstr, Base64.DEFAULT);
	} catch (Exception te) {
	    tb = null;
	}
	if (tb == null) {
	    Log.e(TAG, "ndefWrite: tag invalid");
	    return "tag invalid";
	}
	byte mb[];
	try {
	    mb = Base64.decode(msg, Base64.DEFAULT);
	} catch (Exception me) {
	    mb = null;
	}
	if (mb == null) {
	    Log.e(TAG, "ndefWrite: message invalid");
	    return "message invalid";
	}
	if (tag == null) {
	    Log.e(TAG, "ndefWrite: no current tag");
	    return "no current tag";
	}
	if (!Arrays.equals(tag.getId(), tb)) {
	    Log.e(TAG, "ndefWrite: tag not current: " + tagstr + " expecting " +
		  Base64.encodeToString(tag.getId(), Base64.DEFAULT));
	    return "wrong tag id";
	}
	try {
	    NdefMessage ndmsg = new NdefMessage(mb);
	    int size = ndmsg.toByteArray().length;
	    Ndef ndef = Ndef.get(tag);
	    if (ndef == null) {
		NdefFormatable nfmt = NdefFormatable.get(tag);
		if (nfmt == null) {
		    Log.e(TAG, "ndefWrite: unsupported tech");
		    return "unsupported tech";
		}
		nfmt.connect();
		nfmt.format(ndmsg);
		nfmt.close();
	    } else {
		ndef.connect();
		if (!ndef.isWritable()) {
		    ndef.close();
		    Log.e(TAG, "ndefWrite: read only tag");
		    return "read only tag";
		}
		if (size > ndef.getMaxSize()) {
		    ndef.close();
		    Log.e(TAG, "ndefWrite: message too large (" + size + ">" +
			  ndef.getMaxSize() + ")");
		    return "message too large";
		}
		ndef.writeNdefMessage(ndmsg);
		ndef.close();
	    }
	} catch (FormatException fe) {
	    Log.e(TAG, "ndefWrite: format exception: " + fe.toString());
	    return "wrong ndef format";
	} catch (IOException ie) {
	    Log.e(TAG, "ndefWrite: I/O exception: " + ie.toString());
	    return "I/O error";
	} catch (Exception e) {
	    Log.e(TAG, "ndefWrite: other exception: " + e.toString());
	    return "unknown error";
	}
	return null;
    }

    public static String ndefFormat(String tagstr, String msg) {
	Tag tag = mNfcTag;
	byte tb[];
	try {
	    tb = Base64.decode(tagstr, Base64.DEFAULT);
	} catch (Exception te) {
	    tb = null;
	}
	if (tb == null) {
	    Log.e(TAG, "ndefFormat: tag invalid");
	    return "tag invalid";
	}
	byte mb[] = null;
	try {
	    mb = Base64.decode(msg, Base64.DEFAULT);
	} catch (Exception me) {
	    mb = null;
	}
	if (mb == null) {
	    Log.e(TAG, "ndefFormat: message invalid");
	    return "message invalid";
	}
	if (tag == null) {
	    Log.e(TAG, "ndefFormat: no current tag");
	    return "no current tag";
	}
	if (!Arrays.equals(tag.getId(), tb)) {
	    Log.e(TAG, "ndefFormat: tag not current: " + tagstr + " expecting " +
		  Base64.encodeToString(tag.getId(), Base64.DEFAULT));
	    return "wrong tag id";
	}
	try {
	    NdefFormatable nfmt = NdefFormatable.get(tag);
	    if (nfmt == null) {
		Log.e(TAG, "ndefFormat: unsupported tech");
		return "unsupported tech";
	    }
	    nfmt.connect();
	    NdefMessage ndmsg = new NdefMessage(mb);
	    nfmt.format(ndmsg);
	    nfmt.close();
	} catch (FormatException fe) {
	    Log.e(TAG, "ndefFormat: format exception: " + fe.toString());
	    return "wrong ndef format";
	} catch (IOException ie) {
	    Log.e(TAG, "ndefFormat: I/O exception: " + ie.toString());
	    return "I/O error";
	} catch (Exception e) {
	    Log.e(TAG, "ndefFormat: other exception: " + e.toString());
	    return "unknown error";
	}
	return null;
    }

    /*
     * Native setenv
     */

    public static native int nativeSetenv(String name, String value);