SEAndroid中各种实体的SContext 定义

介绍进程、文件/目录、服务、系统属性等SContext 定义

进程的SContext（以system_server进程为例）（对应每个进程的te文件）

u:r:system_server:s0           system    494   186   system_server
u表示user SELinux用户
r表示SELinux角色
system_server表示domain，该域的权限定义在策略文件system_server.te中
s0表示MLS中的级别，Android中可忽略

file和dir的SContext（以system目录为例）（在file_contexts定义）

drwxr-xr-x root     root              u:object_r:system_file:s0 system
object_r表示文件对象
system_file表示文件类型

fs_use(在fs_use定义)

// to do

生成 文件系统的 SContext （在genfs_contexts定义）

genfscon rootfs / u:object_r:rootfs:s0
genfscon usbfs  / u:object_r:usbfs:s0

property的SContext（在property_contexts定义）

*                       u:object_r:default_prop:s0    //默认property SContext
hw.                     u:object_r:system_prop:s0

service的SContext（在service_contexts定义）

*                       u:object_r:default_android_service:s0   //默认服务SContext
package                 u:object_r:system_server_service:s0     //package 服务  （在shell中执行service list查看所有服务）

JNI 介绍

JNI是Java Native Interface的缩写，它提供了若干的API实现了Java和其他语言的通信（主要是C&C++）。

JNI 类型

jni中结构体层次结构

jni sign 参照表

下面是访问String的一些方法：

GetStringUTFChars 将jstring转换成为UTF-8格式的char*    /  ReleaseStringUTFChars  释放指向UTF-8格式的char*的指针
GetStringChars    将jstring转换成为Unicode格式的char*  /  ReleaseStringChars     释放指向Unicode格式的char*的指针

NewStringUTF      创建一个UTF-8格式的String对象
NewString         创建一个Unicode格式的String对象
GetStringUTFLengt 获取 UTF-8格式的char*的长度　
GetStringLength   获取Unicode格式的char*的长度

首先，Java中创建（实例化）对象的五种方式，如下
1、用new语句创建对象，这是最常见的创建对象的方法。
2、通过工厂方法返回对象，如：String str = String.valueOf(23);
3、运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。如：Object obj = Class.forName(“java.lang.Object”).newInstance();
4、调用对象的clone()方法。
5、通过I/O流（包括反序列化），如运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

示例

package org.whb.test.demo724;
/*
 * 测试Cloneable接口的使用
 * 包含第一种和第三种方法clone()
 * 不过要注意在clone()中深复制和潜复制的理解
 * 实例化对象 
 */
class Person implements Cloneable{
    private String name;
    private int age;

  public Person( String name,int age) {
    this.name = name; 
    this.age = age;
  }

  public int getAge() {
   return age;
  }

  public void setAge(int age) {
   this.age = age;
  }

 public String getName() {
  return name;
 }

 public void setName(String name){
      this.name =name;
    }

@Override
 public Object clone() throws CloneNotSupportedException {
  // TODO Auto-generated method stub
  return super.clone();
 }
  @Override
 public String toString() {
  // TODO Auto-generated method stub
  return "姓名是："+name+"; 年龄是："+age;
 }

}

public class TestClone{
 public static void main(String[] args){
   Person p1 = new Person("王豪博",25);
   System.out.println(p1);
   Person p2 =null;
   try {
     p2 = (Person)p1.clone();
   } catch (CloneNotSupportedException e) {
    // TODO Auto-generated catch block
     e.printStackTrace();
   }
   p2.setName("春香");
   p2.setAge(24);
   System.out.println(p2);
  }
}

/*
 * 通过反射对对象进行初始化
 * 注意必须有无参数的Constructor
 * 实例化Class类然后调用newInstance()方法
 */
package org.whb.test.demo715;
class Person{
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String toString(){
        return "年龄是："+this.age+"  姓名是："+this.name;
    } 

}

public class TestClass {
    public static void main(String[] args){
        Class< ?> c1 = null;
        try{
            c1 = Class.forName("org.whb.test.demo715.Person");
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }   
        Person p1 = null;
        try {
            p1 =(Person)c1.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        p1.setAge(12);
        p1.setName("haobo");
        System.out.println(p1);
    }
}


/*
 * 对象的序列化和反序列化测试类.

    *1、序列化是干什么的？
    简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自 己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
    *2、什么情况下需要序列化 
    a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
    b）当你想用套接字在网络上传送对象的时候；
    c）当你想通过RMI传输对象的时候；
    *
    *3、相关注意事项
    a）序列化时，只对对象的状态进行保存，而不管对象的方法；
    b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
    c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
    d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
    1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输 等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
    2.资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分 配，而且，也是没有必要这样实现。

*/

package org.whb.test.demo724;
import java.io.*; 
import java.util.Date;

public class ObjectSaver { 
    public static void main(String[] args) throws Exception { 
        ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream("D:/objectFile.swf"));

        //序列化对象 
        Customer customer = new Customer("haobo", 24); 
        out.writeObject("你好!"); 
        out.writeObject(new Date()); 
        out.writeObject(customer); 
        out.writeInt(123); //写入基本类型数据 
        out.close(); 

        //反序列化对象 
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/objectFile.swf")); 
        System.out.println("obj1=" + (String) in.readObject()); 
        System.out.println("obj2=" + (Date) in.readObject()); 
        Customer obj3 = (Customer) in.readObject(); 
        System.out.println("obj3=" + obj3); 
        int obj4 = in.readInt(); 
        System.out.println("obj4=" + obj4); 
        in.close(); 
    } 
} 

class Customer implements Serializable { 
    private static final long serialVersionUID = -88175599799432325L; 
    private String name; 
    private int age; 
    public Customer(String name, int age) { 
        this.name = name; 
        this.age = age; 
    }
    public String toString() { 
        return "name=" + name + ", age=" + age; 
    } 
}

/* 打印输出
 * obj1=你好!
 * obj2=Sat Jul 24 21:18:19 CST 2010
 * obj3=name=haobo, age=24
 * obj4=123
 */

附（C++中实例化对象）

A a = new A; 和 A a=new A(); （推荐使用这个）都是调用A类的默认构造函数，指针a在函数栈中，指向内容在堆中。
但是如果单独声明一个A 类变量，如：A a；则调用的是默认构造函数，对象a整个在函数栈中。
但是不能写成 A a(); 来调用默认构造函数！！因为这种形式会被识别成一个：名称为a的不接受任何参数，返回值为A类型的函数！

看下面的代码片段，父类和子类都实现了接口A

Class Base `implements  A`
Class Sub extends Base  `implements  A`

就是说子类Sub实现A有什么用？

我原来认为是多余的。实际上， 子类再次实现父类实现的接口是为了强制子类(SUB)重写父类(BASE)中实现的所有接口中的方法。

现实中的例子：
父类：public abstract class AbstractList extends AbstractCollection implements List {}

子类：public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable {}

这篇博文只能算是笔记了，比较杂。

Pid : Linux 进程ID
Tid : Linux 线程ID，或者任务ID
UID : Android中的UID不同于Linux中的UID，Linux中UID是针对多用户操作系统中用于区分用户的；而Android中的UID是分配给各个进程使用，用来做权限管理的。
userID : Android自从Android 4.2.2 之后就有支持多用户的拓展，只不过现在只有user 只有一个 = 0，故userID = 0。
AppID : 单用户时和UID值是一样的。
shareUserId : 拥有同一个UID的多个APK可以配置成运行在同一个进程中. 所以默认就是可以互相访问任意数据. 也可以配置成运行成不同的进程, 同时可以访问其他APK的数据目录下的数据库和文件. 就像访问本程序的数据一样.
e.g. android:sharedUserId=”android.uid.system” “android.uid.phone” “android.uid.bluetooth”
“android.uid.shell” “android.uid.calendar” “android.uid.shared” “android.media” “android.uid.systemui”

e.g. android:sharedUserId="com.rainwii.share"

签名 : 1. Android 标准签名为platform media shared testkey/releasekey； 2. 第三方签名
可以在源码的/build/target/product/security里面看到对应的密钥，其中shared.pk8代表私钥，shared.x509.pem公钥，一定是成对出现的。

LOCAL_CERTIFICATE : 配置应用使用什么签名 platform media shared 或者第三方签名 presigned， 默认配置的话使用testkey/releasekey .

注：
shareUserID一样的，签名也必须相同

命令行启动jar包

export CLASSPATH=/system/framework/sg.jar
trap “” HUP
exec app_process /system/bin com.china_liantong.commands.SGCmdToolManager systemtask exec “ping -c 1 192.168.0.1”

exec app_process /system/bin com.china_liantong.commands.SGCmdToolManager systemtask exec “ping -c 1 192.168.0.1”

获取包名

String callingApp = context.getPackageManager().getNameForUid(Binder.getCallingUid());
context.getPackageName 区别

sendBroadcast & BroadcastReceiver

MainActivity.java
public class MainActivity extends Activity {
private static final String MY_ACTION = “com.android.notification.MY_ACTION”;
public void onCreate(Bundle savedInstanceState) {
btn.setOnClickListener(listener);
}
private OnClickListener listener = new OnClickListener() {
@Override
public void onClick(View v) {
// 实例化Intent
Intent intent = new Intent();
// 设置Intent action属性
intent.setAction(MY_ACTION);
// 发起广播
sendBroadcast(intent);
}
}
}

MyReceiver.java
public class MyReceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent) {
// 实例化Intent
Intent i = new Intent();
// 在新的任务中启动Activity
i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 设置Intent启动的组件名称
i.setClass(context, SecondActivity.class);
// 启动Activity显示通知
context.startActivity(i);
}
}

SecondActivity.java
public class SecondActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {

}

}

AndroidManifest.xml
<?xml version=”1.0” encoding=”utf-8”?>

屏幕超时休眠配置：

packages/apps/Settings/res/values/arrays.xml //菜单项配置

frameworks/base/packages/SettingsProvider/res/values/defaults.xml // 默认值配置
Lollipop/device/rockchip/common/overlay_screenoff/frameworks/base/packages/SettingsProvider/res/values/defaults.xml //默认值配置

adb connect 提示 unable to connect to解决方法

使用ADB 连接Android设备时，提示连接失败，在Android设备中执行以下命令，重试

setprop service.adb.tcp.port 5555
stop adbd
start adbd

layout_gravity 和 gravity

layout_gravity 表示本组件自身在父组件中的位置
gravity 表示本组件的子组件在组件中的位置

Sqlite3 在Android shell中操作

adb shell
cd /data/data/com.android.providers.securityguard/databases
sqlite3 securityguard.db
.table
select * from SystemTaskPerm;

INSERT INTO SystemTaskPerm (id, ‘packagename’, ‘cmd’, ‘args’, ‘reserved’, auth) VALUES (4, ‘com.a.b’, ‘ip’ , ‘’, ‘’, 1);

1. 权限
   每个程序在安装时都有建立一个系统ID，如app_15，用以保护数据不被其它应用获取。Android根据不同的用户和组，
   分配不同权限，比如访问SD卡，访问网络等等。底层映射为Linux权限。

2. Android权限的实现
   1) 第一层：由应用设置，修改AndroidManifest.xml，形如：
   

   应用申请权限
   1) 应用开发者通过AndroidManifest.xml中<uses-permission>指定对应权限，再映射到底层的用户和组，默认情况下不设定特殊的权限。  
      AndroidManifest加入权限后系统安装程序时会在图形界面中提示权限
   
   2) 如果是缺少某个权限（程序中使用的某种权限而在AndroidManifest.xml中并未声名），
      程序运行时会在logcat中打印出错误信息requires <permission>
   3) 与某个进程使用相同的用户ID
      应用程序可与系统中已存在的用户使用同一权限，需要在AndroidManifest.xml中设置sharedUserId，如android:sharedUserId="android.uid.shared"，作用是获得系统权限，
      但是这样的程序属性只能在build整个系统时放进去（就是系统软件）才起作用，共享ID的程序必须是同一签名的
   

   2) 第二层：框架层，权限对应组，frameworks/base/data/etc/platform.xml，形如：

   
   
   

   3) 第三层：系统层，系统的权限，system/core/include/private/android_filesystem_config.h,形如：
   #define AID_INET 3003 //建立SOCKET的权限
   ……
   { “inet”, AID_INET, },

3. 系统权限
   特殊权限的用户

   a)  system     uid 1000
   b)  radio      uid 1001
   

4. permission权限查看

   $ adb shell
   $ pm list permissions
   

5. framework层对权限的判断
   1) 相关源码实现

   frameworks/base/services/Java/com/android/server/PackageManagerService.java
   frameworks/base/services/java/com/android/server/am/ActivityManagerService.java
   

   2) 在系统层，如何查看某个应用的权限

   a) 在应用进程开启时，ActivityManagerService.java会在logcat中输出该应用的权限，形如：
       I/ActivityManager(1730): Start proc com.anbdroid.phone for restart com.android.phone:pid=2605 uid=1000 gids={3002,3001,3003}
      即它有3001,3002,3003三个权限：访问蓝牙和建立socket
   b) 注意：此打印输出在应用第一次启动时。如果进程已存在，需要先把对应进程杀掉，以保证该进程重新启动，才能显示
   c) 具体实现，见： framewors/base/services/java/com/android/server/am/ActivityManagerService.java的
      函数startProcessLocked()，其中取其组信息的具本语句是mContext.getPackageManager().getPackageGids(app.info.packageName);
   

6. 参考
   http://wenku.baidu.com/view/7754a4360b4c2e3f5727634e.html

常规内部类

public class A{
  private int a = 100;

  class B{  //其中可以直接使用外部类A中的实例变量和方法
    int b;
  }
  public void createB{  //在外部类方法中创建内部类实例
    B c = new B();
  }

  public static void main(){
    A out = new A();
    A.B in = new out.B(); //内部类通过A实例创建对象

  }
}

静态内部类（静态内部类与静态内部方法相似）

由于static内部类不具有任何对外部类实例的引用，因此static内部类中不能使用this关键字来访问外部类中的实例成员，
但是可以访问外部类中的static成员。

MyOuter.MyInner si=new MyOuter.MyInner();//静态内部类不通过外部实例就可以创建对象

局部内部类

在方法体或语句块（包括方法、构造方法、局部块或静态初始化块）内部定义的类成为局部内部类。
局部内部类不能加任何访问修饰符，因为它只对局部块有效。

1.局部内部类只在方法体中有效，就想定义的局部变量一样，在定义的方法体外不能创建局部内部类的对象
1.方法定义局部内部类同方法定义局部变量一样，不能使用private、protected、public等访问修饰说明符修饰，也不能使用static修饰，但可以使用final和 abstract修饰

匿名内部类

定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建，
放到与一起完成，或者说在定义类的同时就创建一个类

new ClassOrInterfaceName(){
    /*类体*/ 
}

匿名内部类可以继承一个类或实现一个接口，这里的ClassOrInterfaceName是匿名内部类所继承的类名或实现的接口名。
但匿名内部类不能同时实现一个接口和继承一个类，也不能实现多个接口。如果实现了一个接口，该类是Object类的直接子类，
匿名类继承一个类或实现一个接口，不需要extends和implements关键字。

由于匿名内部类没有名称，所以类体中不能定义构造方法，由于不知道类名也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。此外，上式是一个表达式，返回的是一个对象的引用，所以可以直接使用或将其复制给一个对象变量。例：

TypeName obj=new Name（）{
    /*此处为类体*/
}

同样，也可以将构造的对象作为调用的参数。例：
someMethod(new Name(){
/此处为类体/
}
);