¿Dónde está android.os.SystemProperties?

Question

Estoy buscando en el código de la cámara de Android, y cuando intento importar android.os.SystemProperties, que no puede ser encontrado.

Aquí está el archivo que estoy viendo:
https: //android.googlesource.com/platform/packages/apps/Camera/+/eclair-release/src/com/android/camera/VideoCamera.java

He creado un nuevo proyecto 2.1 y trató de importar este espacio de nombres de nuevo, pero todavía no se puede encontrar. Revisé https://developer.android.com y SystemProperties no estaba en la lista.

¿Me he perdido algo?

Answer 1

Esta es la clase en el código fuente de Android:

https : //android.googlesource.com/platform/frameworks/base/+/eclair-release/core/java/android/os/SystemProperties.java

Ver {@hide} en el JavaDoc clase? Eso significa que esta clase no se exporta como parte del SDK público.

Los usos aplicación de la cámara, ya que es interno y que no va a usar el SDK pública para construirlo.

Usted todavía puede ser capaz de obtener en esta clase

1. por reflexión o

2. por conseguir la fuente, la eliminación de @hide y hacer su propio SDK personalizado.

Sin embargo casi por definición, que ahora va 'off SDK' y por lo tanto su aplicación también se puede romper o conseguir un comportamiento diferente en versiones del sistema operativo como la gente Android harán poco esfuerzo para no cambiar esta clase entre las versiones.

Answer 2

Si se utiliza la opción "reflexión", puede utilizar la clase de abajo

package com.etc.etc;

import java.io.File;
import java.lang.reflect.Method;
import android.content.Context;
import dalvik.system.DexFile;


public class SystemPropertiesProxy
{

/**
 * This class cannot be instantiated
 */
private SystemPropertiesProxy(){

}

    /**
     * Get the value for the given key.
     * @return an empty string if the key isn't found
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static String get(Context context, String key) throws IllegalArgumentException {

        String ret= "";

        try{

          ClassLoader cl = context.getClassLoader(); 
          @SuppressWarnings("rawtypes")
          Class SystemProperties = cl.loadClass("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[1];
          paramTypes[0]= String.class;

          Method get = SystemProperties.getMethod("get", paramTypes);

          //Parameters
          Object[] params= new Object[1];
          params[0]= new String(key);

          ret= (String) get.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            ret= "";
            //TODO
        }

        return ret;

    }

    /**
     * Get the value for the given key.
     * @return if the key isn't found, return def if it isn't null, or an empty string otherwise
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static String get(Context context, String key, String def) throws IllegalArgumentException {

        String ret= def;

        try{

          ClassLoader cl = context.getClassLoader(); 
          @SuppressWarnings("rawtypes")
          Class SystemProperties = cl.loadClass("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[2];
          paramTypes[0]= String.class;
          paramTypes[1]= String.class;          

          Method get = SystemProperties.getMethod("get", paramTypes);

          //Parameters
          Object[] params= new Object[2];
          params[0]= new String(key);
          params[1]= new String(def);

          ret= (String) get.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            ret= def;
            //TODO
        }

        return ret;

    }

    /**
     * Get the value for the given key, and return as an integer.
     * @param key the key to lookup
     * @param def a default value to return
     * @return the key parsed as an integer, or def if the key isn't found or
     *         cannot be parsed
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static Integer getInt(Context context, String key, int def) throws IllegalArgumentException {

        Integer ret= def;

        try{

          ClassLoader cl = context.getClassLoader(); 
          @SuppressWarnings("rawtypes")
          Class SystemProperties = cl.loadClass("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[2];
          paramTypes[0]= String.class;
          paramTypes[1]= int.class;  

          Method getInt = SystemProperties.getMethod("getInt", paramTypes);

          //Parameters
          Object[] params= new Object[2];
          params[0]= new String(key);
          params[1]= new Integer(def);

          ret= (Integer) getInt.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            ret= def;
            //TODO
        }

        return ret;

    }

    /**
     * Get the value for the given key, and return as a long.
     * @param key the key to lookup
     * @param def a default value to return
     * @return the key parsed as a long, or def if the key isn't found or
     *         cannot be parsed
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static Long getLong(Context context, String key, long def) throws IllegalArgumentException {

        Long ret= def;

        try{

          ClassLoader cl = context.getClassLoader();
          @SuppressWarnings("rawtypes")
              Class SystemProperties= cl.loadClass("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[2];
          paramTypes[0]= String.class;
          paramTypes[1]= long.class;  

          Method getLong = SystemProperties.getMethod("getLong", paramTypes);

          //Parameters
          Object[] params= new Object[2];
          params[0]= new String(key);
          params[1]= new Long(def);

          ret= (Long) getLong.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            ret= def;
            //TODO
        }

        return ret;

    }

    /**
     * Get the value for the given key, returned as a boolean.
     * Values 'n', 'no', '0', 'false' or 'off' are considered false.
     * Values 'y', 'yes', '1', 'true' or 'on' are considered true.
     * (case insensitive).
     * If the key does not exist, or has any other value, then the default
     * result is returned.
     * @param key the key to lookup
     * @param def a default value to return
     * @return the key parsed as a boolean, or def if the key isn't found or is
     *         not able to be parsed as a boolean.
     * @throws IllegalArgumentException if the key exceeds 32 characters
     */
    public static Boolean getBoolean(Context context, String key, boolean def) throws IllegalArgumentException {

        Boolean ret= def;

        try{

          ClassLoader cl = context.getClassLoader(); 
          @SuppressWarnings("rawtypes")
          Class SystemProperties = cl.loadClass("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[2];
          paramTypes[0]= String.class;
          paramTypes[1]= boolean.class;  

          Method getBoolean = SystemProperties.getMethod("getBoolean", paramTypes);

          //Parameters         
          Object[] params= new Object[2];
          params[0]= new String(key);
          params[1]= new Boolean(def);

          ret= (Boolean) getBoolean.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            ret= def;
            //TODO
        }

        return ret;

    }

    /**
     * Set the value for the given key.
     * @throws IllegalArgumentException if the key exceeds 32 characters
     * @throws IllegalArgumentException if the value exceeds 92 characters
     */
    public static void set(Context context, String key, String val) throws IllegalArgumentException {

        try{

          @SuppressWarnings("unused")
          DexFile df = new DexFile(new File("/system/app/Settings.apk"));
          @SuppressWarnings("unused")
          ClassLoader cl = context.getClassLoader(); 
          @SuppressWarnings("rawtypes")
          Class SystemProperties = Class.forName("android.os.SystemProperties");

          //Parameters Types
          @SuppressWarnings("rawtypes")
              Class[] paramTypes= new Class[2];
          paramTypes[0]= String.class;
          paramTypes[1]= String.class;  

          Method set = SystemProperties.getMethod("set", paramTypes);

          //Parameters         
          Object[] params= new Object[2];
          params[0]= new String(key);
          params[1]= new String(val);

          set.invoke(SystemProperties, params);

        }catch( IllegalArgumentException iAE ){
            throw iAE;
        }catch( Exception e ){
            //TODO
        }

    }
}

Answer 3

La clase publicado como una respuesta de Vacío usuario tiene un montón de cosas innecesarias. Aquí está mi clase que utiliza la reflexión sobre android.os.SystemProperties :

/*
 * Copyright (C) 2015 Jared Rummler
 *
 * 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.
 */

/**
 * Gives access to the system properties store. The system properties store contains a list of
 * string key-value pairs.
 */
public class SystemProperties {

  private static final Class<?> SP = getSystemPropertiesClass();

  /**
   * Get the value for the given key.
   */
  public static String get(String key) {
    try {
      return (String) SP.getMethod("get", String.class).invoke(null, key);
    } catch (Exception e) {
      return null;
    }
  }

  /**
   * Get the value for the given key.
   *
   * @return if the key isn't found, return def if it isn't null, or an empty string otherwise
   */
  public static String get(String key, String def) {
    try {
      return (String) SP.getMethod("get", String.class, String.class).invoke(null, key, def);
    } catch (Exception e) {
      return def;
    }
  }

  /**
   * Get the value for the given key, returned as a boolean. Values 'n', 'no', '0', 'false' or
   * 'off' are considered false. Values 'y', 'yes', '1', 'true' or 'on' are considered true. (case
   * sensitive). If the key does not exist, or has any other value, then the default result is
   * returned.
   *
   * @param key
   *     the key to lookup
   * @param def
   *     a default value to return
   * @return the key parsed as a boolean, or def if the key isn't found or is not able to be
   * parsed as a boolean.
   */
  public static boolean getBoolean(String key, boolean def) {
    try {
      return (Boolean) SP.getMethod("getBoolean", String.class, boolean.class)
          .invoke(null, key, def);
    } catch (Exception e) {
      return def;
    }
  }

  /**
   * Get the value for the given key, and return as an integer.
   *
   * @param key
   *     the key to lookup
   * @param def
   *     a default value to return
   * @return the key parsed as an integer, or def if the key isn't found or cannot be parsed
   */
  public static int getInt(String key, int def) {
    try {
      return (Integer) SP.getMethod("getInt", String.class, int.class).invoke(null, key, def);
    } catch (Exception e) {
      return def;
    }
  }

  /**
   * Get the value for the given key, and return as a long.
   *
   * @param key
   *     the key to lookup
   * @param def
   *     a default value to return
   * @return the key parsed as a long, or def if the key isn't found or cannot be parsed
   */
  public static long getLong(String key, long def) {
    try {
      return (Long) SP.getMethod("getLong", String.class, long.class).invoke(null, key, def);
    } catch (Exception e) {
      return def;
    }
  }

  private static Class<?> getSystemPropertiesClass() {
    try {
      return Class.forName("android.os.SystemProperties");
    } catch (ClassNotFoundException shouldNotHappen) {
      return null;
    }
  }

  private SystemProperties() {
    throw new AssertionError("no instances");
  }

}

Answer 4

Después de mucho andar por ahí por fin tengo código de reflexión por encima de trabajo para ambos conjuntos y crear nuevas propiedades del sistema nativos, hay algunas advertencias:

1. Es necesario ser el usuario del sistema, añadir: android:. SharedUserId = "android.uid.system" al manifiesto

2. Es necesario firmar el archivo APK con la clave de la plataforma, hice trampa y apenas overrode la clave de firma predeterminado de depuración en Eclipse como se muestra aquí: http://stoned-android.blogspot.co.uk/2012_01_01_archive.html

3. El nativo de servicio de las propiedades del sistema tiene una ACL que controla todo el acceso de escritura a propiedades que se pueden subvertir un espacio clave (como sys. O depuración.). Ver /system/core/init/property_service.c:

   { "red.", AID_SYSTEM, 0}, { "Prog.", AID_SYSTEM, 0}, { "Tiempo de ejecución.", AID_SYSTEM, 0}, { "Hw.", AID_SYSTEM, 0}, { "Sys.", AID_SYSTEM, 0}, { "Servicio.", AID_SYSTEM, 0}, { "WLAN"., AID_SYSTEM, 0}, { "DHCP.", AID_SYSTEM, 0},

O si usted está rodando su propia acumulación se puede inscribir su propia llave, si realmente quería, pero parece más fácil de reutilizar uno de los anteriores.

Answer 5

exec podría salir al comando getprop:

String line = "";
try {
 Process ifc = Runtime.getRuntime().exec("getprop ro.hardware");
 BufferedReader bis = new BufferedReader(new InputStreamReader(ifc.getInputStream()));
 line = bis.readLine();
} catch (java.io.IOException e) {
}
ifc.destroy();

Answer 6

Después de mucho buscar he encontrado una manera de establecer la propiedad del sistema para Android. Yo no era capaz de encontrar una solución para la versión Android Lollipop. Pero tuve éxito al hacerlo. Para establecer la propiedad del sistema que necesitamos para el uso:

import android.os.SystemProperties
SystemProperties.set(key, value).

por ejemplo. SystemProperties.set("sys.android", 5.0)

Ahora tiene que dar permisos a la nueva propiedad del sistema Ir a /home/inkkashy04/Android_Lollypop/external/sepolicy/property_contexts y conceder permiso adecuado a su propiedad

  

sys.android u: object_r: system_prop: s0

Ahora después de parpadear la imagen se puede ver las propiedades del sistema enumerados por orden:

adb shell getprop

Answer 7

enfoque Gradle:

String SDK_DIR = System.getenv("ANDROID_SDK_HOME")
if(SDK_DIR == null) {
    Properties props = new Properties()
    props.load(new FileInputStream(project.rootProject.file("local.properties")))
    SDK_DIR = props.get('sdk.dir');
}
dependencies {
    compileOnly files("${SDK_DIR}/platforms/android-25/data/layoutlib.jar")
}