/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package java.lang; import dalvik.system.VMRuntime; import dalvik.system.VMStack; import java.io.Console; import java.io.FileDescriptor; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintStream; import java.nio.channels.Channel; import java.nio.channels.spi.SelectorProvider; import java.util.AbstractMap; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Properties; import java.util.PropertyPermission; import java.util.Set; /** * Provides access to system-related information and resources including * standard input and output. Enables clients to dynamically load native * libraries. All methods of this class are accessed in a static way and the * class itself can not be instantiated. * * @see Runtime */ public final class System { /** * Default input stream. */ public static final InputStream in; /** * Default output stream. */ public static final PrintStream out; /** * Default error output stream. */ public static final PrintStream err; private static Properties systemProperties; static { // TODO: all three streams are buffered in Harmony. err = new PrintStream(new FileOutputStream(FileDescriptor.err)); out = new PrintStream(new FileOutputStream(FileDescriptor.out)); in = new FileInputStream(FileDescriptor.in); } /** * Sets the standard input stream to the given user defined input stream. * * @param newIn * the user defined input stream to set as the standard input * stream. */ public static void setIn(InputStream newIn) { setFieldImpl("in", "Ljava/io/InputStream;", newIn); } /** * Sets the standard output stream to the given user defined output stream. * * @param newOut * the user defined output stream to set as the standard output * stream. */ public static void setOut(java.io.PrintStream newOut) { setFieldImpl("out", "Ljava/io/PrintStream;", newOut); } /** * Sets the standard error output stream to the given user defined output * stream. * * @param newErr * the user defined output stream to set as the standard error * output stream. */ public static void setErr(java.io.PrintStream newErr) { setFieldImpl("err", "Ljava/io/PrintStream;", newErr); } /** * Prevents this class from being instantiated. */ private System() { } /** * Copies {@code length} elements from the array {@code src}, * starting at offset {@code srcPos}, into the array {@code dst}, * starting at offset {@code dstPos}. * * @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 system time in milliseconds since January 1, 1970 * 00:00:00 UTC. This method shouldn't be used for measuring timeouts or * other elapsed time measurements, as changing the system time can affect * the results. * * @return the local system time in milliseconds. */ public static native long currentTimeMillis(); /** * Returns the current timestamp of the most precise timer available on the * local system. This timestamp can only be used to measure an elapsed * period by comparing it against another timestamp. It cannot be used as a * very exact system time expression. * * @return the current timestamp in nanoseconds. */ public static native long nanoTime(); /** * Causes the virtual machine 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 virtual machine 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) { if (name == null) { throw new NullPointerException(); } return getEnvByName(name); } private static String getenv(String name, String defaultValue) { String value = getEnvByName(name); return (value != null) ? value : defaultValue; } /* * Returns an environment variable. No security checks are performed. * @param var the name of the environment variable * @return the value of the specified environment variable */ private static native String getEnvByName(String name); /** * Returns an unmodifiable map of all available environment variables. * * @return the map representing all environment variables. */ public static Map getenv() { Map map = new HashMap(); int index = 0; String entry = getEnvByIndex(index++); while (entry != null) { int pos = entry.indexOf('='); if (pos != -1) { map.put(entry.substring(0, pos), entry.substring(pos + 1)); } entry = getEnvByIndex(index++); } return new SystemEnvironment(map); } /* * Returns an environment variable. No security checks are performed. The * safe way of traversing the environment is to start at index zero and * count upwards until a null pointer is encountered. This marks the end of * the Unix environment. * @param index the index of the environment variable * @return the value of the specified environment variable */ private static native String getEnvByIndex(int index); /** * Returns the inherited channel from the creator of the current virtual * machine. * * @return the inherited {@link Channel} or {@code null} if none exists. * @throws IOException * if an I/O error occurred. * @see SelectorProvider * @see SelectorProvider#inheritedChannel() */ public static Channel inheritedChannel() throws IOException { return SelectorProvider.provider().inheritedChannel(); } /** * Returns the system properties. Note that this is not a copy, so that * changes made to the returned Properties object will be reflected in * subsequent calls to getProperty and getProperties. * * @return the system properties. */ public static Properties getProperties() { if (systemProperties == null) { initSystemProperties(); } return systemProperties; } private static void initSystemProperties() { VMRuntime runtime = VMRuntime.getRuntime(); Properties p = new Properties(); String projectUrl = "http://www.android.com/"; String projectName = "The Android Project"; p.put("java.boot.class.path", runtime.bootClassPath()); p.put("java.class.path", runtime.classPath()); p.put("java.class.version", "46.0"); p.put("java.compiler", ""); p.put("java.ext.dirs", ""); p.put("java.home", getenv("JAVA_HOME", "/system")); p.put("java.io.tmpdir", "/tmp"); p.put("java.library.path", getenv("LD_LIBRARY_PATH")); p.put("java.net.preferIPv6Addresses", "true"); p.put("java.specification.name", "Dalvik Core Library"); p.put("java.specification.vendor", projectName); p.put("java.specification.version", "0.9"); p.put("java.vendor", projectName); p.put("java.vendor.url", projectUrl); p.put("java.version", "0"); p.put("java.vm.name", "Dalvik"); p.put("java.vm.specification.name", "Dalvik Virtual Machine Specification"); p.put("java.vm.specification.vendor", projectName); p.put("java.vm.specification.version", "0.9"); p.put("java.vm.vendor", projectName); p.put("java.vm.version", runtime.vmVersion()); p.put("file.separator", "/"); p.put("line.separator", "\n"); p.put("path.separator", ":"); p.put("java.runtime.name", "Android Runtime"); p.put("java.runtime.version", "0.9"); p.put("java.vm.vendor.url", projectUrl); p.put("file.encoding", "UTF-8"); p.put("user.language", "en"); p.put("user.region", "US"); p.put("user.home", getenv("HOME", "")); p.put("user.name", getenv("USER", "")); for (String arg : runtime.properties()) { int split = arg.indexOf('='); String key = arg.substring(0, split); String value = arg.substring(split + 1); p.put(key, value); } systemProperties = p; } /** * Returns the value of a particular system property or {@code null} if no * such property exists. * *

The following properties are always provided by the virtual machine: *

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Name Meaning Example
file.separator {@link java.io.File#separator} {@code /}
java.class.path System class path {@code .}
java.class.version Maximum supported .class file version {@code 46.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 Default 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 {@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
* * @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. * * @param prop * the name of the system property to look up. * @param defaultValue * the return value if the system property with the given name * does not exist. * @return the value of the specified system property or the {@code * defaultValue} if the property does not exist. */ public static String getProperty(String prop, String defaultValue) { if (prop.isEmpty()) { throw new IllegalArgumentException(); } return getProperties().getProperty(prop, defaultValue); } /** * Sets the value of a particular system property. * * @param prop * the name of the system property to be changed. * @param value * the value to associate with the given property {@code prop}. * @return the old value of the property or {@code null} if the property * didn't exist. */ public static String setProperty(String prop, String value) { if (prop.isEmpty()) { throw new IllegalArgumentException(); } return (String) getProperties().setProperty(prop, value); } /** * Removes a specific system property. * * @param key * the name of the system property to be removed. * @return the property value or {@code null} if the property didn't exist. * @throws NullPointerException * if the argument {@code key} is {@code null}. * @throws IllegalArgumentException * if the argument {@code key} is empty. */ public static String clearProperty(String key) { if (key == null) { throw new NullPointerException(); } if (key.isEmpty()) { throw new IllegalArgumentException(); } return (String) getProperties().remove(key); } /** * 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); /** * 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()); } /** * Provides a hint to the virtual machine that it would be useful to attempt * to perform any outstanding object finalization. */ public static void runFinalization() { Runtime.getRuntime().runFinalization(); } /** * Ensures that, when the virtual machine 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. * * @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 queried with non-String keys values. */ static class SystemEnvironment extends AbstractMap { private final Map map; public SystemEnvironment(Map map) { this.map = Collections.unmodifiableMap(map); } @Override public Set> entrySet() { return map.entrySet(); } @Override public String get(Object key) { return map.get(toNonNullString(key)); } @Override public boolean containsKey(Object key) { return map.containsKey(toNonNullString(key)); } @Override public boolean containsValue(Object value) { return map.containsValue(toNonNullString(value)); } private String toNonNullString(Object o) { if (o == null) { throw new NullPointerException(); } return (String) o; } } }