The source and destination arrays can be the same array, * in which case copying is performed as if the source elements * are first copied into a temporary array and then into the * destination array. * * @param src * the source array to copy the content. * @param srcPos * the starting index of the content in {@code src}. * @param dst * the destination array to copy the data into. * @param dstPos * the starting index for the copied content in {@code dst}. * @param length * the number of elements to be copied. */ public static native void arraycopy(Object src, int srcPos, Object dst, int dstPos, int length); /** * Returns the current time in milliseconds since January 1, 1970 00:00:00.0 UTC. * *
This method always returns UTC times, regardless of the system's time zone. * This is often called "Unix time" or "epoch time". * Use a {@link java.text.DateFormat} instance to format this time for display to a human. * *
This method shouldn't be used for measuring timeouts or * other elapsed time measurements, as changing the system time can affect * the results. Use {@link #nanoTime} for that. */ public static native long currentTimeMillis(); /** * Returns the current timestamp of the most precise timer available on the * local system, in nanoseconds. Equivalent to Linux's {@code CLOCK_MONOTONIC}. * *
This timestamp should only be used to measure a duration by comparing it
* against another timestamp from the same process on the same device.
* Values returned by this method do not have a defined correspondence to
* wall clock times; the zero value is typically whenever the device last booted.
* Use {@link #currentTimeMillis} if you want to know what time it is.
*/
public static native long nanoTime();
/**
* Causes the VM to stop running and the program to exit. If
* {@link #runFinalizersOnExit(boolean)} has been previously invoked with a
* {@code true} argument, then all objects will be properly
* garbage-collected and finalized first.
*
* @param code
* the return code.
*/
public static void exit(int code) {
Runtime.getRuntime().exit(code);
}
/**
* Indicates to the VM that it would be a good time to run the
* garbage collector. Note that this is a hint only. There is no guarantee
* that the garbage collector will actually be run.
*/
public static void gc() {
Runtime.getRuntime().gc();
}
/**
* Returns the value of the environment variable with the given name {@code
* var}.
*
* @param name
* the name of the environment variable.
* @return the value of the specified environment variable or {@code null}
* if no variable exists with the given name.
*/
public static String getenv(String name) {
return getenv(name, null);
}
private static String getenv(String name, String defaultValue) {
if (name == null) {
throw new NullPointerException("name == null");
}
String value = Libcore.os.getenv(name);
return (value != null) ? value : defaultValue;
}
/**
* Returns an unmodifiable map of all available environment variables.
*
* @return the map representing all environment variables.
*/
public static Map The following properties are always provided by the Dalvik VM:
* It is a mistake to try to override any of these. Doing so will have unpredictable results.
*
* @param propertyName
* the name of the system property to look up.
* @return the value of the specified system property or {@code null} if the
* property doesn't exist.
*/
public static String getProperty(String propertyName) {
return getProperty(propertyName, null);
}
/**
* Returns the value of a particular system property. The {@code
* defaultValue} will be returned if no such property has been found.
*/
public static String getProperty(String name, String defaultValue) {
checkPropertyName(name);
return getProperties().getProperty(name, defaultValue);
}
/**
* Sets the value of a particular system property.
*
* @return the old value of the property or {@code null} if the property
* didn't exist.
*/
public static String setProperty(String name, String value) {
checkPropertyName(name);
return (String) getProperties().setProperty(name, value);
}
/**
* Removes a specific system property.
*
* @return the property value or {@code null} if the property didn't exist.
* @throws NullPointerException
* if the argument is {@code null}.
* @throws IllegalArgumentException
* if the argument is empty.
*/
public static String clearProperty(String name) {
checkPropertyName(name);
return (String) getProperties().remove(name);
}
private static void checkPropertyName(String name) {
if (name == null) {
throw new NullPointerException("name == null");
}
if (name.isEmpty()) {
throw new IllegalArgumentException("name is empty");
}
}
/**
* Returns the {@link java.io.Console} associated with this VM, or null.
* Not all VMs will have an associated console. A console is typically only
* available for programs run from the command line.
* @since 1.6
*/
public static Console console() {
return Console.getConsole();
}
/**
* Returns null. Android does not use {@code SecurityManager}. This method
* is only provided for source compatibility.
*
* @return null
*/
public static SecurityManager getSecurityManager() {
return null;
}
/**
* Returns an integer hash code for the parameter. The hash code returned is
* the same one that would be returned by the method {@code
* java.lang.Object.hashCode()}, whether or not the object's class has
* overridden hashCode(). The hash code for {@code null} is {@code 0}.
*
* @param anObject
* the object to calculate the hash code.
* @return the hash code for the given object.
* @see java.lang.Object#hashCode
*/
public static native int identityHashCode(Object anObject);
/**
* Returns the system's line separator. On Android, this is {@code "\n"}. The value
* comes from the value of the {@code line.separator} system property when the VM
* starts. Later changes to the property will not affect the value returned by this
* method.
* @since 1.7
* @hide 1.7 - fix documentation references to "line.separator" in Formatter.
*/
public static String lineSeparator() {
return lineSeparator;
}
/**
* Loads and links the dynamic library that is identified through the
* specified path. This method is similar to {@link #loadLibrary(String)},
* but it accepts a full path specification whereas {@code loadLibrary} just
* accepts the name of the library to load.
*
* @param pathName
* the path of the file to be loaded.
*/
public static void load(String pathName) {
Runtime.getRuntime().load(pathName, VMStack.getCallingClassLoader());
}
/**
* Loads and links the library with the specified name. The mapping of the
* specified library name to the full path for loading the library is
* implementation-dependent.
*
* @param libName
* the name of the library to load.
* @throws UnsatisfiedLinkError
* if the library could not be loaded.
*/
public static void loadLibrary(String libName) {
Runtime.getRuntime().loadLibrary(libName, VMStack.getCallingClassLoader());
}
/**
* @hide internal use only
*/
public static void logE(String message) {
log('E', message, null);
}
/**
* @hide internal use only
*/
public static void logE(String message, Throwable th) {
log('E', message, th);
}
/**
* @hide internal use only
*/
public static void logI(String message) {
log('I', message, null);
}
/**
* @hide internal use only
*/
public static void logI(String message, Throwable th) {
log('I', message, th);
}
/**
* @hide internal use only
*/
public static void logW(String message) {
log('W', message, null);
}
/**
* @hide internal use only
*/
public static void logW(String message, Throwable th) {
log('W', message, th);
}
private static native void log(char type, String message, Throwable th);
/**
* Provides a hint to the VM that it would be useful to attempt
* to perform any outstanding object finalization.
*/
public static void runFinalization() {
Runtime.getRuntime().runFinalization();
}
/**
* Ensures that, when the VM is about to exit, all objects are
* finalized. Note that all finalization which occurs when the system is
* exiting is performed after all running threads have been terminated.
*
* @param flag
* the flag determines if finalization on exit is enabled.
* @deprecated this method is unsafe.
*/
@SuppressWarnings("deprecation")
@Deprecated
public static void runFinalizersOnExit(boolean flag) {
Runtime.runFinalizersOnExit(flag);
}
/**
* Sets all system properties. This does not take a copy; the passed-in object is used
* directly. Passing null causes the VM to reinitialize the properties to how they were
* when the VM was started.
*/
public static void setProperties(Properties p) {
systemProperties = p;
}
/**
* Throws {@code SecurityException}.
*
* Security managers do not provide a secure environment for
* executing untrusted code and are unsupported on Android. Untrusted code
* cannot be safely isolated within a single VM on Android, so this method
* always throws a {@code SecurityException}.
*
* @param sm a security manager
* @throws SecurityException always
*/
public static void setSecurityManager(SecurityManager sm) {
if (sm != null) {
throw new SecurityException();
}
}
/**
* Returns the platform specific file name format for the shared library
* named by the argument.
*
* @param userLibName
* the name of the library to look up.
* @return the platform specific filename for the library.
*/
public static native String mapLibraryName(String userLibName);
/**
* Sets the value of the named static field in the receiver to the passed in
* argument.
*
* @param fieldName
* the name of the field to set, one of in, out, or err
* @param stream
* the new value of the field
*/
private static native void setFieldImpl(String fieldName, String signature, Object stream);
/**
* The unmodifiable environment variables map. System.getenv() specifies
* that this map must throw when passed non-String keys.
*/
static class SystemEnvironment extends AbstractMap
*
*
*
*
* Name Meaning Example file.separator {@link java.io.File#separator} {@code /} java.class.path System class path {@code .} java.class.version (Not useful on Android) {@code 50.0} java.compiler (Not useful on Android) Empty java.ext.dirs (Not useful on Android) Empty java.home Location of the VM on the file system {@code /system} java.io.tmpdir See {@link java.io.File#createTempFile} {@code /sdcard} java.library.path Search path for JNI libraries {@code /system/lib} java.vendor Human-readable VM vendor {@code The Android Project} java.vendor.url URL for VM vendor's web site {@code http://www.android.com/} java.version (Not useful on Android) {@code 0} java.specification.version VM libraries version {@code 0.9} java.specification.vendor VM libraries vendor {@code The Android Project} java.specification.name VM libraries name {@code Dalvik Core Library} java.vm.version VM implementation version {@code 1.2.0} java.vm.vendor VM implementation vendor {@code The Android Project} java.vm.name VM implementation name {@code Dalvik} java.vm.specification.version VM specification version {@code 0.9} java.vm.specification.vendor VM specification vendor {@code The Android Project} java.vm.specification.name VM specification name {@code Dalvik Virtual Machine Specification} line.separator The system line separator {@code \n} os.arch OS architecture {@code armv7l} os.name OS (kernel) name {@code Linux} os.version OS (kernel) version {@code 2.6.32.9-g103d848} path.separator See {@link java.io.File#pathSeparator} {@code :} user.dir Base of non-absolute paths {@code /} user.home (Not useful on Android) Empty user.name (Not useful on Android) Empty