精华内容
下载资源
问答
  • android 系统属性介绍

    千次阅读 2018-06-13 23:23:14
    android 系统属性介绍 本文属于原创,转载请声明。 前言 Android系统中有一套全局统一的属性管理机制,每个属性都有一个名称和值。属性被大量使用在Android系统中,用来记录系统设置或进程之间的信息交换。每一...

    android 系统属性介绍

    本文属于原创,转载请声明。

    前言

    Android系统中有一套全局统一的属性管理机制,每个属性都有一个名称和值。属性被大量使用在Android系统中,用来记录系统设置或进程之间的信息交换。每一个安卓的工作者,无论是上层还是底层都必须深刻清晰的理解使用系统属性。

    一.属性类别

    • ro开头的属性,表明该属性是只读的,重启失效。系统启动之后第一次设置之后不能修改,重启之后不保存。
    • persist开头的属性,表明该属性可修改的,重启还保存原来的值。
    • ctrl.startctrl.stop两个属性比较特殊,是用来启动和停止init.rc中定义的服务(ini服务相关的可以参考我的另一篇博客:https://blog.csdn.net/u012890170/article/details/80659425
      一旦我们设置 ctrl.start等一某个服务,init进程就会启动这个服务。设置ctrl.stop就会去停止某个服务。
    • 其他格式的都是:可修改,重启不保存。

    二.属性权限

    当然上面所说的可修改也是有一定条件的,就是有权限的用户才可以修改和设置。
    在文件中/system/core/init/property_service.c
    说明了不同开头的属性对应不同的权限

    struct {
        const char *prefix;
        unsigned int uid;
        unsigned int gid;
    } property_perms[] = {
        { "net.rmnet0.",      AID_RADIO,    0 },
        { "net.gprs.",        AID_RADIO,    0 },
        { "net.ppp",          AID_RADIO,    0 },
        { "net.qmi",          AID_RADIO,    0 },
        { "net.lte",          AID_RADIO,    0 },
        { "net.cdma",         AID_RADIO,    0 },
        { "ril.",             AID_RADIO,    0 },
        { "gsm.",             AID_RADIO,    0 },
        { "persist.radio",    AID_RADIO,    0 },
        { "net.dns",          AID_RADIO,    0 },
        { "sys.usb.config",   AID_RADIO,    0 },
        { "net.",             AID_SYSTEM,   0 },
        { "dev.",             AID_SYSTEM,   0 },
        { "runtime.",         AID_SYSTEM,   0 },
        { "hw.",              AID_SYSTEM,   0 },
        { "sys.",             AID_SYSTEM,   0 },
        { "sys.powerctl",     AID_SHELL,    0 },
        { "service.",         AID_SYSTEM,   0 },
        { "wlan.",            AID_SYSTEM,   0 },
        { "bluetooth.",       AID_BLUETOOTH,   0 },
        { "dhcp.",            AID_SYSTEM,   0 },
        { "dhcp.",            AID_DHCP,     0 },
        { "debug.",           AID_SYSTEM,   0 },
        { "debug.",           AID_SHELL,    0 },
        { "log.",             AID_SHELL,    0 },
        { "service.adb.root", AID_SHELL,    0 },
        { "service.adb.tcp.port", AID_SHELL,    0 },
        { "persist.sys.",     AID_SYSTEM,   0 },
        { "persist.linkin.",     AID_SYSTEM,   0 },
        { "persist.service.", AID_SYSTEM,   0 },
        { "persist.security.", AID_SYSTEM,   0 },
        { "sys_graphic.", AID_MEDIA,   0 },//add for sys_graphic.cam_hal.ver in cameraHal
        { "persist.service.bdroid.", AID_BLUETOOTH,   0 },
        { "selinux."         , AID_SYSTEM,   0 },
        { "persist.audio.",   AID_SYSTEM,   0 },
        { "persist.audio.",   AID_MEDIA,   0 },
        { "media.",           AID_SYSTEM,   0 },
        { "media.",           AID_MEDIA,   0 },
        { "dolby.audio",      AID_MEDIA,    0 },
        { "dolby.audio",      AID_SYSTEM,    0 },
        { "persist.dolby.",   AID_MEDIA,   0 },
        { "persist.dolby.",   AID_SYSTEM,   0 },
        { "persist.bootanima.",   AID_GRAPHICS,   0 },
        { "sys_graphic.",   AID_SYSTEM,   0 },
        { NULL, 0, 0 }
    };

    实际上用不同用户权限限制的实现也是在这个文件中
    就是通过调用下面的函数进行权限的检查

    static int check_control_perms(const char *name, unsigned int uid, unsigned int gid, char *sctx) {
          if(strcmp("iso_operate",name)==0)
          {
                return 1;
          }
        int i;
        if (uid == AID_SYSTEM || uid == AID_ROOT) //判读是不是 SYSTEM/ROOT
          return check_control_mac_perms(name, sctx);
    
        /* Search the ACL */ 
        for (i = 0; control_perms[i].service; i++) { //如果普通用户,判读uid gid ,如果有权限就返回相关的逻辑,没权限返回0
            if (strcmp(control_perms[i].service, name) == 0) {
                if ((uid && control_perms[i].uid == uid) ||
                    (gid && control_perms[i].gid == gid)) {
                    return check_control_mac_perms(name, sctx);
                }
            }
        }
        return 0;
    }

    如果我们上层有些需要使用一些属性进行某些逻辑的实现等,可以在这里加入过滤,不进行权限的限制或者放开某个应该的使用权限。

    三.不同层操作属性的不同方法

    Java层
    String data = SystemProperties.get("sys.haha.karaoke_mode");
    SystemProperties.set("sys.haha.karaoke_mode",data);

    这里只列出最基本的接口,还有其他获取boolean或者String的接口

    native层
    #include <cutils/properties.h>
    property_set("persist.sys.pic_time", delay);
    shell
    setprop ro.haha.mode mode0
    getprop ro.haha.mode

    四.属性相关的源代码介绍

    展开全文
  • SystemProperties系统属性

    千次阅读 2018-03-05 19:56:36
    SystemProperties系统属性,对整个系统全局共享,通过SystemProperties.set()/SystemProperties.get()这两个函数对系统的属性进行读取和设置。 可以通过ADB shell进行查看,具体方法是adb shell getprop +...

    一 : 

    SystemProperties系统属性,对整个系统全局共享,通过SystemProperties.set()/SystemProperties.get()这两个函数对系统的属性进行读取和设置。



    可以通过ADB shell进行查看,具体方法是adb shell getprop +“具体的属性对应的名称”就可以读取你想要的属性了。如果不知道具体的属性是什么名称也可以先输入adb shell getprop命令回车,就会显示出所有手机所支持的属性名称及对应的值。


    主要属性如下(参考机为联想P780海外版本):


    (1)gsm开头的是移动电话的一些版本信息(软硬件,基带版本等信息)、所在国家、漫游状态、序列号等信息等一系列与sim相关的信息


    (2)ro开头的是只读属性,一旦赋值不能修改


    (3)sys开头的是系统信息


    (4)persist和ril开头的不知道啥意思


    (5)init.svc手机当前进程的状态(启动的显示running未启动的显示stopped)。进程是否启动是有init.rc文件中定义的


    (6)net开头的是与网络相关的信息,比如dns、主机名、为各功能预留的缓冲区大小


    (7)dhcp.wlan 是网关、IP地址等无线网络相关信息;


    (8)external_sd_path 是外部存储SD卡的路径


    (9)fmradio.driver 是FMradio相关属性


    (10)其他的信息



    二:


    Android 的系统属性包括两部分:文件保存的持久属性和每次开机导入的cache属性。前者主要保存在下面几个文件中:


    bionic/libc/include/sys/_system_properties.h


    1     #define PROP_SERVICE_NAME "property_service"
    2     #define PROP_PATH_RAMDISK_DEFAULT  "/default.prop"
    3     #define PROP_PATH_SYSTEM_BUILD     "/system/build.prop"
    4     #define PROP_PATH_SYSTEM_DEFAULT   "/system/default.prop"
    5     #define PROP_PATH_LOCAL_OVERRIDE   "/data/local.prop"


    后者则通过frameworks/base/core/java/android/os/SystemProperties.java的接口定义,




     1     private static native String native_get(String key);
     2     private static native String native_get(String key, String def);
     3     private static native void native_set(String key, String def);
     4     public static void set(String key, String val) {
     5         if (key.length() > PROP_NAME_MAX) {
     6             throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX);
     7         }
     8         if (val != null && val.length() > PROP_VALUE_MAX) {
     9             throw new IllegalArgumentException("val.length > " +
    10                 PROP_VALUE_MAX);
    11         }
    12         native_set(key, val);
    13     }


    该接口类在初始化运行环境中注册对应的cpp接口android_os_SystemProperties.cpp,实际操作通过JNI调用的是cpp文件对应的接口:


    frameworks/base/core/jni/AndroidRuntime.cpp


    1     namespace android {
    2     extern int register_android_os_SystemProperties(JNIEnv *env);
    3     }


    frameworks/base/core/jni/android_os_SystemProperties.cpp


     1     static void SystemProperties_set(JNIEnv *env, jobject clazz, jstring keyJ, jstring valJ)
     2     {
     3         int err;
     4         const char* key;
     5         const char* val;
     6         key = env->GetStringUTFChars(keyJ, NULL);
     7         if (valJ == NULL) {
     8             val = "";       /* NULL pointer not allowed here */
     9         } else {
    10             val = env->GetStringUTFChars(valJ, NULL);
    11         }
    12         err = property_set(key, val);
    13         env->ReleaseStringUTFChars(keyJ, key);        
    14         if (valJ != NULL) {
    15             env->ReleaseStringUTFChars(valJ, val);
    16         }
    17     }


    设置key的value时,需要作鉴权,根据设置程序所在进程的fd获知uid值,比如system server进程可以设置net打头的key,不可以设置gsm打头的key,相关的定义如下:


    system/core/include/private/android_filesystem_config.h


    1     #define AID_ROOT             0  /* traditional unix root user */
    2     #define AID_SYSTEM        1000  /* system server */
    3     #define AID_RADIO         1001  /* telephony subsystem, RIL */
    4     #define AID_DHCP          1014  /* dhcp client */
    5     #define AID_SHELL         2000  /* adb and debug shell user */
    6     #define AID_CACHE         2001  /* cache access */
    7     #define AID_APP          10000 /* first app user */


    system/core/init/property_service.c


     1     #define PERSISTENT_PROPERTY_DIR  "/data/property"
     2     struct {
     3         const char *prefix;
     4         unsigned int uid;
     5     } property_perms[] = {
     6         { "net.rmnet0.",    AID_RADIO },
     7         { "net.gprs.",      AID_RADIO },
     8         { "ril.",           AID_RADIO },
     9         { "gsm.",           AID_RADIO },
    10         { "net.dns",        AID_RADIO },
    11         { "net.usb0",       AID_RADIO },
    12         { "net.",           AID_SYSTEM },
    13         { "dev.",           AID_SYSTEM },
    14         { "runtime.",       AID_SYSTEM },
    15         { "hw.",            AID_SYSTEM },
    16         { "sys.",        AID_SYSTEM },
    17         { "service.",    AID_SYSTEM },
    18         { "wlan.",        AID_SYSTEM },
    19         { "dhcp.",        AID_SYSTEM },
    20         { "dhcp.",        AID_DHCP },
    21         { "debug.",        AID_SHELL },
    22         { "log.",        AID_SHELL },
    23         { "service.adb.root",    AID_SHELL },
    24         { "persist.sys.",    AID_SYSTEM },
    25         { "persist.service.",   AID_SYSTEM },
    26         { NULL, 0 }
    27     };
    28     int property_set(const char *name, const char *value)
    29     {
    30         property_changed(name, value);
    31         return 0;
    32     }
    33     int start_property_service(void)
    34     {
    35         int fd;
    36 
    37         load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
    38         load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
    39         load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);
    40         /* Read persistent properties after all default values have been loaded. */
    41         load_persistent_properties();
    42 
    43         fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0);
    44         if(fd < 0) return -1;
    45         fcntl(fd, F_SETFD, FD_CLOEXEC);
    46         fcntl(fd, F_SETFL, O_NONBLOCK);
    47 
    48         listen(fd, 8);
    49         return fd;
    50     }
    51     void handle_property_set_fd(int fd)
    52     {
    53         switch(msg.cmd) {
    54         case PROP_MSG_SETPROP:
    55             msg.name[PROP_NAME_MAX-1] = 0;
    56             msg.value[PROP_VALUE_MAX-1] = 0;
    57 
    58             if(memcmp(msg.name,"ctl.",4) == 0) {
    59                 if (check_control_perms(msg.value, cr.uid)) {
    60                     handle_control_message((char*) msg.name + 4, (char*) msg.value);
    61                 } else {
    62                     ERROR("sys_prop: Unable to %s service ctl [%s] uid: %d pid:%d\n",
    63                             msg.name + 4, msg.value, cr.uid, cr.pid);
    64                 }
    65             } else {
    66                 if (check_perms(msg.name, cr.uid)) {
    67                     property_set((char*) msg.name, (char*) msg.value);
    68                 } else {
    69                     ERROR("sys_prop: permission denied uid:%d  name:%s\n",
    70                           cr.uid, msg.name);
    71                 }
    72             }
    73             break;
    74 
    75         default:
    76             break;
    77         }
    78     }


    在开机启动后的init操作中,会执行一个loop循环,当检测到有新的设置时,进入设置流程,鉴权失败会提示相关的异常,如sys_prop: permission denied uid:1000  name:gsm.phone.id


    system/core/init/init.c


     1     void property_changed(const char *name, const char *value)
     2     {
     3         if (property_triggers_enabled) {
     4             queue_property_triggers(name, value);
     5             drain_action_queue();
     6         }
     7     }
     8     int main(int argc, char **argv)
     9     {
    10         parse_config_file("/init.rc");
    11         qemu_init();
    12         device_fd = device_init();
    13         property_init();
    14         fd = open(console_name, O_RDWR);
    15         property_set_fd = start_property_service();
    16         ufds[0].fd = device_fd;
    17         ufds[0].events = POLLIN;
    18         ufds[1].fd = property_set_fd;
    19         ufds[1].events = POLLIN;
    20         ufds[2].fd = signal_recv_fd;
    21         ufds[2].events = POLLIN;
    22         fd_count = 3;
    23         for(;;) {
    24             if (ufds[0].revents == POLLIN)
    25                 handle_device_fd(device_fd);
    26 
    27             if (ufds[1].revents == POLLIN)
    28                 handle_property_set_fd(property_set_fd);
    29             if (ufds[3].revents == POLLIN)
    30                 handle_keychord(keychord_fd);
    31         }
    32         return 0;
    33     }



    3.Android属性系统

    介绍了Android中三种方式来设置和获取属性。


    Native代码中通过property_get/property_set来读取和设置属性。


    属性(property)系统对Android来说是一个重要的功能。他作为一个系统服务管理着系统的配置和状态,所有的这些系统配置和状态都是属性(property)。属性(property)是一对键/值(key/value)组合,键和值都是字符串类型。总体感觉属性系统非常像Windows的注册表的功能。Androd中非常多的应用程序和库直接或者间接的依赖于属性系统,并由此决定其运行期的行为。例如:adbd进程通过属性来决定是否当前运行在模拟器中。再比如:java.io.File.pathSeparator方法返回存储在属性服务中的值。


    属性系统怎样工作


        属性系统宏观的结构图如下所示:


        从图中我们可以看出Android属性系统由有三个进程,一组属性文件和一块共享内存组成。这块共享内存保存着系统中所有的属性记录,只有Property service能写这块共享内存,并且Property service负责将属性文件中的属性记录加载到共享内存中。


        属性读取进程(property consumer)把这块共享内存映射到自己的进程空间,然后直接读取它。属性设置进程(property setter)也加载这块共享到他的进程空间,但是他不能直接写这块共享内存。当他需要增加或者修改属性的时候,通过Unix Socket发生属性给Property service,Property service将代表设置进程写入共享内存和属性文件。


        Property service运行于init进程中。init进程首先创建一块共享内存,并把他的句柄fd存放在这块内存中,init进程通过mmap带MAP_SHARE标志的系统调用,把这块内存映射到他的虚拟空间中,最终这块内存所有的更新将会被所有映射这块共享内存的进程看到。共享内存句柄fd和共享内存大小存储在系统环境变量“ANDROID_PROPERTY_WORKSPACE”中,所有的进程包括属性设置进程和属性读取进程都将通过这个系统环境变量获得共享内存的句柄fd和大小,然后把这块内存映射到他们自己的虚拟空间。共享内存布局如下:


        然后,init进程将会从以下文件中加载属性:


       1: /default.prop
       2: /system/build.prop
       3: /system/default.prop
       4: /data/local.prop
        下一步是启动Property service。这步中,将会创建一个Unix Socket服务器,这个Socket有一个闻名的名称“/dev/socket/property_service”。最后init进入死循环,等待socket的连接请求。


        在读取进程中,当它初始化libc库的时候,将会获得属性系统共享内存的句柄和大小(bionic/libc/bionic/libc_init_common.c __libc_init_common函数)。并把这块共享内存映射到自己的进程虚拟空间中(bionic/libc/bionic/system_properties.c __system_properties_init函数)。这样读取进程将会向访问普通内存一样访问属性系统的共享内存了。


        当前,属性不能被删除。也就是说一旦属性被创建,将不可以被删除,但是它们可以被修改。


    怎样获得和设置属性


        在Android中有三种方式来设置和获取属性:


    1、Native代码


        当编写Native的程序时,可以使用property_get和property_set API来获得和设置属性。使用这两个API必须要包含头文件cutils/properties.h和链接libcutil库。


    2、Java代码


        Android在Java库中提供System.getProperty和System.setProperty方法,我们Java程序可以通过他们来设置和获得属性。


        但是请注意!虽然从语法上面看Java的代码和Native代码非常相近,但是Java版本存储把属性存在其他地方,而不是我们上面提到的属性系统中。在JVM中有一个hash表来维护Java的属性。所以Java属性和Android属性是不同的,不能用Java API(System.getProperty和System.setProperty)来设置系统属性。也不能通过Native的方法(property_get和property_set)设置Java的属性。


    更新:Andrew指出android.os.SystemProperties可以操作Android系统属性(虽然这个类倾向于内部使用)。这个类通过JNI调用Native的property_get和property_set方法来获得和设置属性。


    3、Shell脚本


       Android提供了命令行工具setprop和getprop来设置和获取属性,他们可以在脚本中被使用。


             补充:通过查看property_service.c,我们可以明确以下事实:

    1、  属性名不是随意取的。在property_perms数组中定义了当前系统上可用的所有属性的前缀,以及相对应的存取权限UID。对属性的设置要满足权限要求,同时命名也要在这些定义的范围内。


    2、  PA_COUNT_MAX指定了系统(共享内存区域中)最多能存储多少个属性。


    3、  PROP_NAME_MAX指定了一个属性的key最大允许长度;PROP_VALUE_MAX则指定了value的最大允许长度。

    此外,http://blog.csdn.net/tekkamanitachi/archive/2009/06/18/4280982.aspx 这篇文章翻译了Android的官方文档,从另一个角度叙述了属性系统,需要者请参看。

    property_get/property_set

    http://blog.csdn.net/xujianqun/article/details/6363318

    每个属性都有一个名称和值,他们都是字符串格式。属性被大量使用在Android系统中,用来记录系统设置或进程之间的信息交换。属性是在整个系统中全局可见的。每个进程可以get/set属性。

    在系统初始化时,Android将分配一个共享内存区来存储的属性。这些是由“init”守护进程完成的,其源代码位于:device/system/init。“init”守护进程将启动一个属性服务。

    属性服务在“init”守护进程中运行。每一个客户端想要设置属性时,必须连接属性服务,再向其发送信息。属性服务将会在共享内存区中修改和创建属性。任何客户端想获得属性信息,可以从共享内存直接读取。这提高了读取性能。 客户端应用程序可以调用libcutils中的API函数以GET/SET属性信息。libcutils的源代码位于:device/libs/cutils。API函数是:


    int property_get(const char *key, char *value, const char *default_value);


    int property_set(const char *key, const char *value);


    而libcutils又调用libc中的 __system_property_xxx 函数获得共享内存中的属性。libc的源代码位于:device/system/bionic。


    属性服务调用libc中的__system_property_init函数来初始化属性系统的共享内存。当启动属性服务时,将从以下文件中加载默认属性:

    /default.prop


    /system/build.prop


    /system/default.prop


    /data/local.prop

    属性将会以上述顺序加载。后加载的属性将覆盖原先的值。这些属性加载之后,最后加载的属性会被保持在/data/property中。


    特别属性 如果属性名称以“ro.”开头,那么这个属性被视为只读属性。一旦设置,属性值不能改变。


    如果属性名称以“persist.”开头,当设置这个属性时,其值也将写入/data/property。


    如果属性名称以“net.”开头,当设置这个属性时,“net.change”属性将会自动设置,以加入到最后修改的属性名。(这是很巧妙的。 netresolve模块的使用这个属性来追踪在net.*属性上的任何变化。)

    属性“ ctrl.start ”和“ ctrl.stop ”是用来启动和停止服务。

    每一项服务必须在/init.rc中定义.系统启动时,与init守护进程将解析init.rc和启动属性服务。一旦收到设置“ ctrl.start ”属性的请求,属性服务将使用该属性值作为服务名找到该服务,启动该服务。这项服务的启动结果将会放入“ init.svc.<服务名>“属性中 。客户端应用程序可以轮询那个属性值,以确定结果。


    三:


    查看系统属性build.prop
       Android系统主要通过SystemProperties这个类,直接本地调用来实现创建、获取及修改系统属性。
       Systemproperties类在android.os下,路径为:
       /frameworks/base/core/java/android/os/SystemProperties.java
       
       在手机系统中,我们可以通过如下命令查看到系统属性文件build.prop。
       jinzhimin@jinzhimin:~$ adb remount        //连接到手机系统
       remount succeeded
       jinzhimin@jinzhimin:~$ adb shell           //进入到手机系统
       # cd system                              //连接system目录
       # ls                                     //查看文件
       usr
       xbin
       bin
       res
       media
       lib
       vendor
       etc
       app
       build.prop
       fonts
       secro
       lost+found
       framework
       # exit                                   //退出手机系统
    jinzhimin@jinzhimin:~$ adb pull /system/build.prop /home/jinzhimin/00          //将系统属性文件build.prop拷贝出来
       43 KB/s (3543 bytes in 0.079s)
       jinzhimin@jinzhimin:~$
       
       这样,我们就可以通过build.prop查看手机系统属性了。
       当然了,我们在成功编译完源代码后,在以下目录下也可以看到build.prop。
       /out/target/product/huaqin75_cu_ics/system/build.prop
       
       build.prop是如何生成的呢?Android的build.prop文件是在Android编译时刻收集的各种property,编译完成之后,文件生成在/out/target/product/huaqin75_cu_ics/system/目录下。在Android运行时刻可以通过SystemProperties_get*()读取这些属性值。
       build.prop的生成是由make系统解析build/core/Makefile完成。
    二、Android手机build.prop参数详解(手机型号不同,有些内容可能不一样)
      ro.build.version.sdk=10         sdk版本 10对应2.3ROM
      ro.build.version.release=2.3.4    android版本
      ro.build.date=三 12月 15 20:41:26 CST 2010   时区时间CST可以代表4个时区
      ro.product.model=GT540           手机型号    
      ro.product.locale.language=zh   刷机后默认语言
      ro.product.locale.region=CN     刷机后启动的默认语言
      ro.build.description=soju-user 2.3.3 GRI40 102588 release-keys    内部版本号
      Default network type.   # 0 => WCDMA preferred.         默认网络类型
      wifi.supplicant_scan_interval=120    WIFI扫描时间单位为秒 调大这个值可节约耗电
      ## opengles 2.0               LINUX下针对多媒体的一些功能
      debug.sf.hw=1                    硬件加速设定 0是关闭, 1是开启
      dalvik.vm.heapsize=24m               虚拟内存范围由12M-48M, 默认是24M
      ro.config.ringtone=Playa.ogg                       默认来电铃声
      ro.config.notification_sound=regulus.ogg                            默认通知铃声
      ro.config.alarm_alert=Alarm_Beep_03.ogg                         默认闹钟铃声
      ro.modversion=CyanogenMod-7.0.3-GT540-MUR4IK   MOD版本号
      ro.setupwizard.mode=DISABLED   刷机后设置向导,ENABLED为显示,DISABLED为禁用,OPTIONAL为可选
      persist.sys.timezone=Asia/shanghai"默认时区
      media.stagefright.enable-player=true   与多媒体效果有关 
      media.stagefright.enable-meta=false  与多媒体效果有关 
      media.stagefright.enable-scan=false  与多媒体效果有关 
      media.stagefright.enable-http=false  与多媒体效果有关 
      persist.service.adb.enable=1 开启调试模式
      ro.secure=0 默认开启未知源APK
      ro.allow.mock.location=1 开启模拟位置
      settings.display.autobacklight=1       自动背光默认为开
      debug.sf.nobootanimation=0             控制开机动画的,0为关闭,1为开启!
      ro.config.hw_menu_unlockscreen=true 控制唤醒屏幕的设置
      ro.sf.lcd_density=120 (显示屏分辨率,数值越大分辨率越底)
      view.touch_slop=15 (触摸屏灵敏度,数值越大越灵敏)
      view.minimum_fling_velocity=25 (滑动速度)
      view.scroll_friction=0.008 (滑动误差)
      # RIL specific configuration. (特定设置)
      ro.ril.hsdpa.category=8 (hsdpa全称High Speed Downlink Packet Access中文意思:高速下行分组接入,设置的数越大传输越快)
      ro.ril.gprsclass=12 (GPRS设置)
      # For HSDPA low throughput (HSDPA低输量)
      ro.ril.disable.power.collapse=1 (关闭电源)
      # Modify MMS APN retry timer from 5s to 2s. (修改短信的APN设置5秒为2秒)
      keyguard.no_require_sim=true (手机卡保护设置)
      ro.com.android.dateformat=MM-dd-yyyy (默认时间格式,改为yyyy-MM-dd,显示效果就是XXXX年XX月XX日)
    三、设置系统属性值(实例)
    1.定义: RO_CONFIG_REMOVE_FOCUSMODE
      在mediatek\build\tools\Configoption.pm中
      定义,RO_CONFIG_REMOVE_FOCUSMODE
    2.赋值:RO_CONFIG_REMOVE_FOCUSMODE = true
      在mediatek\config\huaqin75_cu_ics\XXX\ProjectConfig.mk中
      赋值,RO_CONFIG_REMOVE_FOCUSMODE = true
    3.使用:在代码XXX.java中使用

    实例一:
        import android.os.SystemProperties;        //导包
      ……
    final boolean RemoveFocusMode = SystemProperties.getBoolean(
    "ro.config.remove.focusmode",false);  //获得属性值

    if (RemoveFocusMode == true) {            //使用属性值
            // Remove the focus mode if we can use tap-to-focus.
                    removePreference(group, focusMode.getKey());
    }
    else{
               ……
    }
      可以定义这样的系统属性值(布尔值)来取代宏FeatureOption,从而达到控制代码的目的。
      
    实例二:
    另外,这样的用法在情景模式中用得非常多,对初始音量值的定义。
    赋值:RO_CONFIG_GENERAL_VOLUME_RING = 7
      RO_CONFIG_OUTDOOR_VOLUME_RING = 7(ProjectConfig.mk中)
    使用: private static final int DEFAULT_RINGER_VOLUME_GENERAL = SystemProperties.getInt("ro.config.general.volume.ring", 4);
          private static final int DEFAULT_RINGER_VOLUME_OUTDOOR = SystemProperties.getInt("ro.config.outdoor.volume.ring", 6);
      也即在生成的build.prop中:
      ro.config.general.volume.ring=7
      ro.config.outdoor.volume.ring=7
      
    实例三:
      还可以定义初始的字符串的值,例如查询命令:*#8375#。
      赋值:RO_CONFIG_VERSIONCODE = *_86556_(客户要求指令)
      使用:final String specialVersionCode = SystemProperties.get(
       "ro.config.versioncode", "defaultVersionCode");
      specialCode = specialVersionCode.replace("_", "#");

    展开全文
  • Android 系统属性设置和获取原理分析,SystemProperties.set(key,value ); 该方法可以获取系统中的属性值,可以由此获取系统属性值,主要是应用层和和底层都可以获取的配置值,这样可以通过获取属性值来在底层也控制...

    原文:https://www.cnblogs.com/bastard/archive/2012/10/11/2720314.html

    Android System Property

    一 System Property

      代码中大量存在:SystemProperties.set()/SystemProperties.get();通过这两个接口可以对系统的属性进行读取/设置,

    顾名思义系统属性,肯定对整个系统全局共享。通常程序的执行以进程为单位各自相互独立,如何实现全局共享呢?

    System Properties是怎么一回事,又是如何实现的呢?

       属性系统是android的一个重要特性。它作为一个服务运行,管理系统配置和状态。所有这些配置和状态都是属性。
    

    每个属性是一个键值对(key/value pair),其类型都是字符串。

    这些属性可能是有些资源的使用状态,进程的执行状态,系统的特有属性……

       可以通过命令adb shell :
    

        getprop查看手机上所有属性状态值。

       或者 getprop init.svc.bootanim制定查看某个属性状态
    
       使用setprop init.svc.bootanim start 设置某个属性的状态
    

    特别属性 :

      如果属性名称以“ro.”开头,那么这个属性被视为只读属性。一旦设置,属性值不能改变。

      如果属性名称以“persist.”开头,当设置这个属性时,其值也将写入/data/property。

      如果属性名称以“net.”开头,当设置这个属性时,“net.change”属性将会自动设置,以加入到最后修改的属性名。

        (这是很巧妙的。 netresolve模块的使用这个属性来追踪在net.*属性上的任何变化。)

      属性“ ctrl.start ”和“ ctrl.stop ”是用来启动和停止服务。每一项服务必须在/init.rc中定义.系统启动时,与init守护

        进程将解析init.rc和启动属性服务。一旦收到设置“ ctrl.start ”属性的请求,属性服务将使用该属性值作为服务

        名找到该服务,启动该服务。这项服务的启动结果将会放入“ init.svc.<服务名>“属性中。客户端应用程序可以轮询那个属性值,以确定结果。

    二 framework访问系统服务流程

      framework通过SystemProperties接口操作系统属性,SystemProperties通过JNI调用访问系统属性。

     源码路径: \frameworks\base\core\java\android\os\ SystemProperties.java

    public class SystemProperties
    {
        //JNI
        private static native String native_get(String key, String def);
        private static native void native_set(String key, String def);
    
        public static String get(String key, String def) {
            return native_get(key, def);
        }
    
        public static void set(String key, String val) {
            native_set(key, val);
        }
    }
    

    JNI 代码位置: \frameworks\base\core\jni\android_os_SystemProperties.cpp

    获取系统属性 阻塞方式:

    static jstring SystemProperties_getSS()
    {
            len = property_get(key, buf, "");
    } 
    操作在\bionic\libc\bionic\system_properties.c中:
    
    int __system_property_get(const char *name, char *value)
    {
        //数据已经存储在内存中__system_property_area__ 等待读取完返回
        const prop_info *pi = __system_property_find(name);
        return __system_property_read(pi, 0, value);
    } 
      进程启动后数据已经将系统属性数据读取到相应的共享内存中,保存在全局变量__system_property_area__;
    
      进程之间都是独立的,系统属性数据是如何读取到当前进程空间中的呢?后续介绍。
    

    设置属性异步socket通信:

    int __system_property_set(const char *key, const char *value)
    {
          msg.cmd = PROP_MSG_SETPROP;
        strlcpy(msg.name, key, sizeof msg.name);
        strlcpy(msg.value, value, sizeof msg.value);
        err = send_prop_msg(&msg);
    }
    
    static int send_prop_msg(prop_msg *msg)
    {
        //sokcet 通信 /dev/socket/property_service 
        s = socket(AF_LOCAL, SOCK_STREAM, 0);
        connect(s, (struct sockaddr *) &addr, alen)
        send(s, msg, sizeof(prop_msg), 0)
        close(s);
    }

     通过socket向property_service发送消息,property_service运行在哪里呢?

    三 Property Service创建服务端socket

    init进程启动监听过程中: \system\core\init\Init.c

    int main(int argc, char **argv)
    {    
        //加入到action queue队列
        queue_builtin_action(property_service_init_action, "property_service_init");
        for(;;)
            //执行action queue队列
            //接收通过socket向property service 发送的数据;
            nr = poll(ufds, fd_count, timeout);
            ……
            handle_property_set_fd();
    }
    
    static int property_service_init_action(int nargs, char **args)
    {
        start_property_service();
    
    }

    \system\core\init\property_service.c:

    void start_property_service(void)
    {
        //加载属性配置文件
        load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
        load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
        load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);
        load_persistent_properties();
    
        //创建socket资源 并绑定
        fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0);
        //监听
        listen(fd, 8);
    }

      Property Service 是运行在init守护进程中。

      接收到消息之后干什么,还是要先弄清楚整个Property Service是如何实现的呢,后续介绍。

    先看看Property Service接收到消息后的处理。

    四 Property Service 监听socket处理

    Property Service监听socket消息的处理过程:

    void handle_property_set_fd()
    {
        //等待建立通信
        s = accept(property_set_fd, (struct sockaddr *) &addr, &addr_size)
    
        //获取套接字相关信息 uid gid
        getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size);
        //接收属性设置请求消息
        recv(s, &msg, sizeof(msg), 0);
        //处理消息    
        switch(msg.cmd) {
        case PROP_MSG_SETPROP:
            //通过设置系统属性  处理ctl.开头消息
            if(memcmp(msg.name,"ctl.",4) == 0) 
            {
                //权限检测
                if (check_control_perms(msg.value, cr.uid, cr.gid)) 
                {
                    handle_control_message((char*) msg.name + 4, (char*) msg.value);
                }
            } else 
            {
                //更改系统属性值
                if (check_perms(msg.name, cr.uid, cr.gid)) 
                {
                    property_set((char*) msg.name, (char*) msg.value);
                }
            }
        break;
        }
        close(s);
    }

    通过设置系统属性启动/关闭Service:

    权限判断:

    static int check_control_perms(const char *name, unsigned int uid, unsigned int gid) 
    {
        // system /root用户直接有权限
        if (uid == AID_SYSTEM || uid == AID_ROOT)
            return 1;
    
        //查询用户名单,判断是否存在表中并具有对应权限
        for (i = 0; control_perms[i].service; i++) {
            if (strcmp(control_perms[i].service, name) == 0) {
                if ((uid && control_perms[i].uid == uid) ||
                    (gid && control_perms[i].gid == gid)) {
                    return 1;
                }
            }
        }
        return 0;
    }

    所以如果想要应用有权限启动/关闭某Native Service:

      需要具有system/root权限

      找到对应应用uid gid,将应用名称加入到control_perms列表中

    处理消息 可以通过设置系统属性 改变服务的执行状态 start/stop:

    void handle_control_message(const char *msg, const char *arg)
    {
        if (!strcmp(msg,"start")) {
            msg_start(arg);
        } else if (!strcmp(msg,"stop")) {
            msg_stop(arg);
        } else if (!strcmp(msg,"restart")) {
            msg_stop(arg);
            msg_start(arg);
        } 
    }
    
    static void msg_start(const char *name)
    {
        service_start(svc, args);
    }
    void service_start(struct service *svc, const char *dynamic_args){
        //创建进程启动服务
        pid = fork();
        execve(svc->args[0], (char**) svc->args, (char**) ENV);
    
        //修改服务的系统属性 执行状态
        notify_service_state(svc->name, "running");
    }

    连着前面就是ctr.start和ctr.stop系统属性:用来启动和停止服务的。

    例如:

      // start boot animation
    
        property_set("ctl.start", "bootanim");

    在init.rc中表明服务是否在开机时启动:

    service adbd /sbin/adbd
        class core
        disabled //不自动启动

    启动服务的时候会判断:

    static void service_start_if_not_disabled(struct service *svc)
    {
            //判断是否启动
            if (!(svc->flags & SVC_DISABLED)) {
                service_start(svc, NULL);
            }
    }

    修改系统属性值:

    static int check_perms(const char *name, unsigned int uid, unsigned int gid)
    {
        //进行权限检测
        for (i = 0; property_perms[i].prefix; i++) {
            int tmp;
            if (strncmp(property_perms[i].prefix, name,
                        strlen(property_perms[i].prefix)) == 0) {
                if ((uid && property_perms[i].uid == uid) ||
                    (gid && property_perms[i].gid == gid)) {
                    return 1;
                }
            }
        }
    
        return 0;
    }

    看这个修改系统属性权限表:

    property_perms[] = {
        { "net.dns",          AID_RADIO,    0 },
        { "net.",             AID_SYSTEM,   0 },
        { "dev.",             AID_SYSTEM,   0 },
        { "runtime.",         AID_SYSTEM,   0 },
        { "sys.",             AID_SYSTEM,   0 },
        { "service.",         AID_SYSTEM,   0 },
        { "persist.sys.",     AID_SYSTEM,   0 },
        { "persist.service.", AID_SYSTEM,   0 },
        ……
         { NULL, 0, 0 }
    };

      指定了特定的用户有用修改 带有某些前缀的系统属性值。

      到这里基本就是Property对外的基本工作流程,Property Service内部具体如何实现,操作运行,

      跨进程空想内存等问题仍未清除是如何处理的。

    五 属性系统设计
    属性系统的上层架构如下图所示:

      Property Service运行在init进程中,开机从属性文件中加载到共享内存中;设置系统属性通过socket与Property Service通信。

      Property Consumer进程将存储系统属性值的共享内存,加载到当前进程虚拟空间中,实现对系统属性值的读取。

      Property Setter进程修改系统属性,通过socket向Property Service发送消息,更改系统属性值。

    六 属性系统实现

       属性系统设计的关键就是:跨进程共享内存的实现。
    

    下面将看看属性系统实现具体过程:

    Init进程执行:

    int main(int argc, char **argv){
        //将属性系统初始化函数加入action queue
      queue_builtin_action(property_init_action, "property_init");
      for(;;)
    }
    
    static int property_init_action(int nargs, char **args)
    {
        property_init(load_defaults);
    }

    初始化Property Service :

    \system\core\init\property_service.c

    void property_init(bool load_defaults)
    {
        //初始化共享内存空间
        init_property_area();
        //加载属性文件
      load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT);
    }

    初始化共享内存空间:

    static int init_property_area(void)
    {    
        //创建匿名内存空间PA_SIZE = 32768
        init_workspace(&pa_workspace, PA_SIZE)
        //将内存区域分成两部分:属性系统基本信息和属性键值对
        pa_info_array = (void*) (((char*) pa_workspace.data) + PA_INFO_START);
    
        //初始化属性系统信息
        pa = pa_workspace.data;
        memset(pa, 0, PA_SIZE);
        pa->magic = PROP_AREA_MAGIC;
        pa->version = PROP_AREA_VERSION;
    
        /* plug into the lib property services */
        __system_property_area__ = pa;
    }

    system_property_area

      每个进程都会使用此变量,指向系统属性共享内存区域,访问系统属性,很重要。

    位于:\bionic\libc\bionic\system_properties.c中,属于bionic库。后面将介绍各进程如何加载共享内存。

    将文件作为共享内存映射到进程空间内存使用:

    static int init_workspace(workspace *w, size_t size)
    {
        //dev is a tmpfs是一种虚拟内存文件系统
        int fd = open("/dev/__properties__", O_RDWR | O_CREAT, 0600);
        //将文件映射为共享进程空间内存 使其可以与操作内存方式一致
        void *data = mmap(NULL, size, PROT_READ | PROT_WRITE, 
          MAP_SHARED, fd, 0);
        close(fd);
    
        //删除文件
        fd = open("/dev/__properties__", O_RDONLY);
        unlink("/dev/__properties__");
        //保存fd size 将作为环境变量传递给每个进程
         w->data = data; w->size = size; w->fd = fd;
    }

    加载系统属性默认数据文件:

    #define PROP_PATH_RAMDISK_DEFAULT  "/default.prop"
    static void load_properties_from_file(const char *fn)
    {
        //读取系统属性键值对数据写入到共享内存中
        data = read_file(fn, &sz);
        load_properties(data);
    } 

      加上上面所述:Property Service Socket资源的创建,来监听socket通信连接设置系统属性,

      在Init进程中Property Service完成了初始化。

    将得到该内存区域数据结构:

    七 进程共享系统属性内存空间实现

      Property Service运行于init进程中,将文件映射为创建一块共享内存空间,但在整个系统中,

    其他进程也能够读取这块内存映射到当前进程空间中,是如何实现的呢?

    Service进程启动:将共享内存空间fd size作为环境变量传递给新创建进程

    void service_start(struct service *svc, const char *dynamic_args)
    {
        //创建进程
        pid = fork();
    
        if (pid == 0) {
            if (properties_inited()) {
                //获取系统属性空间文件描述
                get_property_workspace(&fd, &sz);
                //dup最小的可用文件描述符
                sprintf(tmp, "%d,%d", dup(fd), sz);
                //加入ANDROID_PROPERTY_WORKSPACE环境变量到ENV 
            //包含共享内存fd
                add_environment("ANDROID_PROPERTY_WORKSPACE", tmp);
            }
            //执行程序 传递环境变量ENV
            execve(svc->args[0], (char**) svc->args, (char**) ENV)
            //设置Service系统属性
            notify_service_state(svc->name, "running");
        }
    }
    
    void get_property_workspace(int *fd, int *sz)
    {
       *fd = pa_workspace.fd;
       *sz = pa_workspace.size;
    }

    共享内存空间fd size作为环境变量传递给新创建进程后,将在何处使用呢?

    将系统属性内存空间映射到当前进程虚拟空间:

    进程在启动时,会加载动态库bionic libc库:

      \bionic\libc\bionic\libc_init_dynamic.c中:

      void attribute((constructor)) __libc_preinit(void);

    根据GCC的constructor/destructor属性:

        给一个函数赋予constructor或destructor,其中constructor在main开始运行之前被调用,

      destructor在main函数结束后被调用。如果有多个constructor或destructor,可以给每个constructor

      或destructor赋予优先级,对于constructor,优先级数值越小,运行越早。destructor则相反。

    多个constructor需要加优先级:

    __attribute__((constructor(1))) void func1()  
    {  
        printf("in constructor of foo\n");  
    }  
    __attribute__((constructor(2))) void func2()  
    {  
        printf("in constructor of foo1\n");  
    } 
    __attribute__((destructor)) void bar()  
    {  
        printf("in constructor of bar\n");  
    }

    __libc_preinit在bionic libc库加载的时候会被调用:

    void __libc_preinit(void)
    {   
        __libc_init_common(elfdata);
    }
    
    void __libc_init_common(uintptr_t *elfdata)
    {
        __system_properties_init();
    }
    
    int __system_properties_init(void)
    {
        prop_area *pa;    int s, fd;        unsigned sz;        char *env;
        //获取环境变量ANDROID_PROPERTY_WORKSPACE 
      //与上面init进程中设置对应
        env = getenv("ANDROID_PROPERTY_WORKSPACE");
        //共享内存文件描述符 内存大小
        fd = atoi(env);
        sz = atoi(env + 1);
        //将文件描述符映射到当前进程虚拟空间内存,实现共享内存
        pa = mmap(0, sz, PROT_READ, MAP_SHARED, fd, 0);
        //全局变量指向共享系统属性内存首地址
        __system_property_area__ = pa;
    }
    

      这就是整个System Property的访问交互和实现过程,具体请参考源码。

    参考文档:

      http://blog.chinaunix.net/uid-20459533-id-3168973.html

      http://www.cnblogs.com/simonshi/archive/2010/04/08/1707516.html

      http://blog.csdn.net/zhangchiytu/article/details/7539101

    Android属性之build.prop生成过程:

      http://www.cnblogs.com/bastard/archive/2013/02/28/2937014.html

    展开全文
  • java JVM 系统属性

    千次阅读 2013-12-15 14:51:23
    import java.util.Properties;... * 可以自己设置一些系统属性,如果自定义的系统属性 * 在JVM启动的默认系统属性里有,会覆盖JVM启动的 * 默认属性,如果没有,则会在启动时添加上这个系统属性
    import java.util.Properties;
    
    
    public class SystemDemo {
    
    	public static void main(String[] args) {
    		
    		/*
    		 * 可以自己设置一些系统属性,如果自定义的系统属性
    		 * 在JVM启动的默认系统属性里有,会覆盖JVM启动的
    		 * 默认属性,如果没有,则会在启动时添加上这个系统属性
    		 */
    		System.setProperty("os.name", "WIN XP");
    		
    		/*
    		 * Properties是HashTable的子类,也就是Map的子类
    		 * 可以通过map的方法取出该集合中的元素
    		 * 该集合中装的都是字符串,没有泛型的定义
    		 */
    		Properties prop = System.getProperties();
    		
    		for(Object obj : prop.keySet()) {
    			String value = (String) prop.get(obj);
    			System.out.println(obj + "=" + value);
    		}
    		
    		/*
    		 * 可以获取某个系统属性的值
    		 * 比如获取系统名称的值,判断
    		 * 是否可以安装本软件
    		 */
    		String value = System.getProperty("os.name");
    		System.out.println("当前系统为:" + value);
    	}
    
    }
    

    展开全文
  • BlackBerry 系统属性

    千次阅读 2010-09-30 11:08:00
    作者:俞伟   BlackBerry 系统属性 本章介绍BlackBerry 系统属性,包括CLDC/MIDP/JTWI,MMAPI,PDAP,LAPI,SATSA,CHAPI,I18N,Bluetooth,WMA, JAX-RPC,JAXP,Browser。列表1 列出各系统...
  • 使用java获取系统属性

    千次阅读 2016-07-28 11:41:30
    使用java获取操作系统环境变量与系统属性
  • Android 添加自定义系统属性

    千次阅读 2018-05-25 18:28:59
    添加的一般都是前缀为“ro.”的只读系统属性 2、device/$(TARGET_DEVICE_DIR)/system.prop 3、在Makefile中的参数ADDITIONAL_BUILD_PROPERTIES中添加 添加的一般是特定平台或者产品的特定系统属性 4、在Makefile...
  • java 设置系统属性

    千次阅读 2014-07-07 21:11:12
    设置系统属性常用:System.setProperty("password","wp"); 在eclipse中可以通过下面方式设置系统属性: Runas--> Run configurations --> Arguments --> VMarguments,在文本框中输入-Duser=Test,这样也可以在...
  • BlackBerry系统属性

    千次阅读 2010-10-07 12:02:00
    BlackBerry系统属性 本章介绍BlackBerry系统属性,包括CLDC/MIDP/JTWI,MMAPI,PDAP,LAPI,SATSA,CHAPI,I18N,Bluetooth,WMA, JAX-RPC,JAXP,Browser。列表1列出各系统属性类别。   ...
  • 如何动态获取Android系统属性

    千次阅读 2018-07-19 18:52:04
    Android设备有很多系统属性,比如说Android版本号,比如品牌,型号,比如厂商操作系统的版本号等,我们经常会要用到这些属性,那怎么获取呢? 最简单的办法,就是连接USB调试后,在命令行输入 adb shell getprop ...
  • adb shell 查看系统属性

    千次阅读 2015-09-28 15:24:33
    1.adb shell 2.getprop可以查看一系列系统属性值 3.getprop |grep xxx.xxx.xx 过滤查看特定系统属性
  • java系统属性(Java System Properties)

    千次阅读 2019-01-09 14:25:23
    java为其操作维护一组系统属性。每个java系统属性都是键值(String-String)对,例如“ java.version”=“1.7.0_09 ”。您可以通过检索所有系统属性,System.getProperties()也可以通过检索单个属性System....
  • Android Systemproperties Android系统属性

    千次阅读 2016-03-14 11:39:59
    Android系统属性的使用方法
  • Java| 获取系统属性和环境变量

    千次阅读 2018-01-29 22:40:37
    系统属性(系统属性是Java获取和设置) - 1.通过虚拟机参数设置系统属性 - 2.Java中获取和设置系统属性 一.环境变量 注意: Linux下获取值是用$,多个路径分割是用:,Windows下获取值是用%变量名%,多个路径分割是...
  • 我们可以通过SystemProperties.set()和 SystemProperties.get()这两个接口来对系统属性进行读取和设置。系统属性是对整个系统全局共享的,属性系统是android的一个重要特性。它作为一个服务运行,管理系统配置和状态...
  • Android怎样使用系统属性

    千次阅读 2013-09-11 11:15:12
    1. 在system.prop里面添加需要使用的系统属性,添加完后需要编译生成system.img 2. 在native层,使用property_set(...)和property_get(...)来存取系统属性 3. 在java层, 使用SystemProperties.set(...)和...
  • Android6.0之修改或者查看系统属性

    万次阅读 2017-01-03 16:15:55
    系统属性值存在于system.prop文件中,也有一些存在于settings中 1,查看settingsprovider中的值的方法 命令为adb shell settings list [system,secure,global] 2,查看系统属性值的方法 命令格式...
  • Android系统属性服务

    千次阅读 2018-10-31 17:39:18
     在android 系统中,为统一管理系统属性,设计了一个统一的属性系统。每个属性都有一个名称和值,他们都是字符串格式。属性被大量使用在Android系统中,用来记录系统设置或进程之间的信息交换。属性是在整个系统...
  • 系统属性: adb shell getprop | grep product 查看机型: adb shell getprop ro.product.model 查看系统版本 获取系统版本:adb shell getprop ro.build.version.release 获取系统api版本:adb shell ...
  • android 获取系统属性的几种方法

    千次阅读 2019-06-10 16:01:24
    在android 系统中有几种获取系统属性的方法命令行、c/c++中以及java代码中 1. 命令行(shell)中 获取系统参数 getprop keys 设置系统参数 setprop keys value 2.在c/c++中 方法一: 在c/c++中properties设置...
  • Android 9无法通过反射获取系统属性

    千次阅读 2019-01-19 11:25:54
    Android 9.0之后获取无法通过反射获取系统属性,如果我们需要知道手机某个属性,可以通过以下的方式.注意:这种方式不能获取所有的属性.不然谷歌显示SystemProper的访问就没有意义了. package ...
  • 方法二:为简单的修改顽固的系统属性 2.使用批处理命令。将以下代码复制至记事本,改后缀名txt为bat! 使用方法:将文件拖入本文件的图标,它就会自动运行了。 @echo off  setlocal ...
  • sysdm.cpl直接打开系统属性

    千次阅读 2015-04-21 18:05:53
    直接打开系统属性 开始->运行->cmd下输入sysdm.cpl,即可打开系统属性页面
  • java系统属性

    千次阅读 2007-08-23 11:17:00
    系统属性是指与用户程序相关的操作系统配置信息以及软件信息。通常与用户程序相关的属性关键字包括: ●file.separator:文件分隔符,Windows环境下为“",Unix环境下为“/”; ●user.home:用户主目录; ●java....
  • Android 系统属性的设置查询

    千次阅读 2014-05-27 20:56:12
    在Android系统通常会自己添加,设置一些系统属性,tongch
  • Android 系统属性SystemProperty分析

    千次阅读 2015-02-28 13:53:34
    From Android System Property 一 System Property  代码中大量存在:System...顾名思义系统属性,肯定对整个系统全局共享。通常程序的执行以进程为单位各自相互独立,如何实现全局共享呢? System Properti
  • 设置系统属性 上一篇文章提到,设置系统属性调用 SystemProperties.set("key", "value"); 即可。那么就从这个方法开始。 framework/base/core/java/android/os/SystemProperties.java ...
  • Android java方法实现调用系统属性

    千次阅读 2016-09-06 14:44:27
    最近在写一个测试apk时需要调用Android的系统属性来设置相关的标志位,但在使用标准的java库中的System.getProperty和System.setProperty方法并不能获得Android中的系统属性,而且会出现空指针崩溃。查阅相关资料...
  • Android系统属性分析ro.persist.

    千次阅读 2015-05-26 15:49:44
    Android 系统属性SystemProperty分析 Android System Property 一 System Property  代码中大量存在:SystemProperties.set()/SystemProperties.get();通过这两个接口可以对系统的属性进行读取/设置, ...
  • 之前使用Native代码的property_get()/property_set()来获取Android系统属性,现在需要改写到Java上面,但是Java里面的getProperty()/setProperty()所操作的属性与上面的是不同的。好在Google提供了一个隐藏类android...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,489
精华内容 40,995
关键字:

系统属性