我们创建了android的工程，接下来有一个问题了，我们该怎么运行创建的程序呢？所以我们需要一个android的模拟器。配置环境的时候我们安装了android的SDK，在eclipse->window下有一个AVD(Android Virtual Device) Manager，点击New…按钮新建一个模拟器，主要要填的有Name，Target，SD Card Size(建议1GB以上，为以后在SD卡中放各种测试文件做准备)，填好以后就可以Create AVD了。由于需要建立和SD Card Size一样大小的映像文件，所以创建的size越大所耗费的时间也就越多，不要着急哦。

创建完模拟器后可以直接在AVDManager中选中刚刚创建的模拟器，点击start…就可以启动模拟器了。模拟器的启动也需要4-5分钟的时间。

当然模拟器也可以在启动程序的时候由eclipse自动启动。

在工程上点击右键，右键菜单中有Debug As/RunAs->Android application；或者选中工程后，run菜单栏中也有同样的菜单项。如果当前模拟器没有启动时，就会先自动启动模拟器。当然前提条件是工程没有错误。

有时候创建出来的模拟器启动后会莫名其妙的异常，可能有效的方法是：

1、  删除当前模拟器重新创建

2、  新建的模拟器异常可以加大SDcard Size的大小

3、  创建模拟器时EnabledSnapshot，该功能会在模拟器关闭时保存当时状态，启动时会自动加载上次的状态

4、  删掉模拟器镜像路径*\.android下的avd文件夹

5、  删掉*\.android下的modem-nv-ram*文件

言归正传，开始和这世界打个招呼吧。

1、新建一个Android的工程

如果开发环境配置正确，在New的菜单中就会出现AndroidProject，就可以新建工程了。

我们在工程名称处写入HelloWorld，选择 Createnew project in workspace，点击Next，选择SDK后继续Next，出现输入包名的界面：

第一次看到这个界面真是犯愁啊，“your.package.namespace”，以前写C++的代码从来没有过包的概念，到底写什么好呢？踌躇了一会，以cs.demo.firstcode为包名，反正都是demo程序，哈哈。

2、工程结构认识

src是工程的代码文件夹，代码文件都放在此文件夹下。cs.demo.firstcode是刚刚建的包，下面是自动创建的HelloWorldActivity.java的代码文件；

gen文件夹下的R.java自动生成的文件，里面记录了程序中用到的各种ID,不要手动修改。当res文件夹下的内容发生变化时，这个R.java文件会自动改变。这个与MFC中的resource.h文件类似。

assets文件夹主要用来存放一些多媒体数据文件，不会被改变

res文件夹存放的是资源相关的文件：

res/drawable*：存放图片文件

res/layout：存放xml的布局文件。写了近三年的自绘界面的代码，看到这个类似MFC的可以拖拽界面元素的功能，着实让我高兴了一下。

res/values：存放字符串，颜色，数组等常量数据，常用的字符串存放在string.xml文件里，在程序中各处就可以使用ID实现字符串共享了。

AndroidManifest.xml：应用的配置文件，声明activity和权限的地方。

题外话：建立工程的其他方式

为什么要写这个呢？我第一次拿到别人提供的工程时，根本就不知道从哪里下手。还是因为VC的思维模式，我在文件夹中找不到工程文件时，就很迷茫了。

一看.project文件还恍然以为找到了入口，不成功又把每个根目录下的文件每个打开了一遍，现在想来真是太可乐了。所以写下简单的创建工程的方式：

1）File->New->Androidproject->Create project from existing source：只需要选择工程所在文件夹就可以了，其他选项都会有默认的设置。

2）File->New->Androidproject->Create project from existing sample：android自带了各种示例程序，选择某个示例程序后，会创建对应的工程

3）File->Import->General->ExistingProjects into Workspace，然后选择文件夹所在的根目录，就可以导入工程了。

大家好，今天我们一起学习通过webView打开网页：

首先还是布局文件main.xml的Code：

利用两个LineraLayout的嵌套显示，上面显示一个编辑框和按钮，下面的是webView用来显示网页，大家要注意两个LineraLayout的android:orientation的属性，最外面的这个是垂直显示，里面的是水平显示，最终得到效果如图：

效果图下面的白色区域就是webView，等Java的Code完成后就能看出效果啦，期待吧！呵呵！

除了openBrowser()方法，其他的和用Intent打开网页是差不多的。

只要利用webView的loadUrl（）方法就能加载网页。好的什么也不说啦！看效果图：

哈哈，不错吧，这样就方便打开别的网页啦！哦！差点忘了，要在AndroidManifest.xml中加入

<uses-permission android:name="android.permission.INTERNET">

否则就不能访问Internet哟！

到这里看了上一篇的同学可能就问，为什么上个例子不要加上这条语句呢？

因为通过Intent就能请求其他应用程序查看网页，而其他应用程序需要在自己的AndroidManifest.xml中请求获得访问Internet的权限。

不知道解释的清楚不？呵呵！

好了今天的就到这里了哟！祝大家一起进步！加油！

本文前提：我们假设已经写了一个驱动程序，它是控制LED的亮灭的，并且创建了一个节点：/dev/vib，也就是通过open这个vib节点，可以read/write/ioctl 操作驱动程序实现LED灯的亮灭控制，具体可以看我另一篇博文《android驱动例子（LED灯控制）》

开发环境 1、ubuntu下的NDK编译环境，2、Esclips开发环境

一、编写JNI模块

当安装好NDK编译环境后，会在它的目录下找到sample目录，它里面有一些例子，可以参考这些例子来写我们自已的模块。

1、 source文件夹下，新建“LEDSJNI”文件夹。

2、 Source/LEDSJNI/jni/目录下，新建“vib-jni.c”

vib-jni.c文件

#include <string.h>
#include <jni.h>
#include <fcntl.h> /*包括文件操作，如open() read() close() write()等*/
//----for output the debug log message
#include <android/log.h>
#define  LOG_TAG    "vib-jni"
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
#define  DEVICE_NAME  "/dev/vib"  //device point
#define  VIB_ON 0x11
#define  VIB_OFF 0x22
int fd;
jstring
Java_com_auly_control_vibClass_stringFromJNI( JNIEnv* env,
                                                  jobject thiz )
{
    return (*env)->NewStringUTF(env, "Hello from JNI--Peter for vib!");//打印字符串
}
 
jint   
Java_com_auly_control_vibClass_Init( JNIEnv*  env )
{
   LOGE("vibClass_Init() /n");
   fd = open(DEVICE_NAME,O_RDWR);//打开设备
   LOGE("vibClass_Init()-> fd = %d  /n",fd);
   if(fd == -1)
       {
           LOGE("open device %s error /n ",DEVICE_NAME);//打印调试信息
           return 0;
   }
   else
       {
          return 1;
       }
}
 
jint 
Java_com_auly_control_vibClass_IOCTLVIB( JNIEnv*  env, jobject  thiz, jint controlcode )
{
    int CTLCODE = controlcode;
    LOGE("IOCTLVIB() = %x --vibClass_IOCTLVIB /n",CTLCODE);
       switch(CTLCODE)
           {
        case VIB_ON:
                {
                    ioctl(fd,VIB_ON);//调用驱动程序中的ioctrl接口，把命令VIB_ON传下去，实现硬件操作
                break;
                }
        case VIB_OFF:
                {
                    ioctl(fd,VIB_OFF);//调用驱动程序中的ioctrl接口，把命令VIB_OFF传下去，实现硬件操作
                break;
                }        
        default:break;
       }
       return 1;
 }

3、相同目录下的新建Android.mk如下

Android.mk文件

LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE    := vib-jni
LOCAL_SRC_FILES := vib-jni.c
LOCAL_CFLAGS    := -Werror
LOCAL_LDLIBS    := -llog -lGLESv2 //__android_log_print 函数
include $(BUILD_SHARED_LIBRARY)

可以看到，主要是修改LOCAL_SRC_FILES指向源文件的名称！

还有一点很重要，如果要使用调试LOG 打印，也就是__android_log_print 函数。要在LOCAL_LDLIBS中添加-llog,如上面的Android.mk所示。

4、编译JNI模块

#cd /home/workspace/android-ndk-r4b/sources/LEDSJNI

进到刚才写的JNI目录

 

#ndk-build

编译JNI,编译成功后，会在LEDSJNI文件夹下生成libs和obj两个文件夹，并在

LEDSJNI/libs/armeabi下得到目标文件libvib-jni.so

（目前LEDSJNI文件夹只有3个目录jni,libs,obj）

二、JAVA程序

1、Eclipse新建工程

拷贝LEDSJNI目录到Windows下，例如C盘下。然后在它里面新建Eclipse 工程。

新键工程后，

如果出现如下错误：

ERROR: Unable to open class file C:/LEDSJNI/gen/com/auly/control/R.java: No such file or directory

解决方法如下：

对着该工程鼠标右键 》bulid path 》configure build path》java build path》order and Export

 

把里面的android 2.1勾上，Build project，就OK了

然后 Run as > Android application，就会出现android的模拟器了，里面跑个helloworld出来。

2、加入button和文本输出

程序到上面为止代码是ADT自动生成的，似乎与我们一点关系也没有。那我们来改一下代码，因为我们调用JNI接口是为了访问驱动程序操作硬件的，例如写，读，打开LED，关闭LED等等，由按钮触发的动作。

第一步是，增加两个Button，，在main.xml里描述一下：打开Res > layout> main.xml 文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    androidrientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello"
    />
 <Button android:id="@+id/led_on"/*这表示需要一个唯一的UID来作为Button的ID，它的引用名是led_on。*/
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/LEDon">/*表示这个按钮的文本是来源于另一个资源描述文件strings.xml里的文:字资源LEDon */
        <requestFocus/>
</Button>
 <Button android:id="@+id/led_off"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/LEDoff">
        <requestFocus/>
 </Button> 
</LinearLayout>

实际代码中，把注释去掉，否则编译不过的。

3、加入输出字符串资源

工程 > values > strings.xml 文件

修改如下

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Led 控制程序</string>
    <string name="app_name">LEDAPP</string>
<string name="LEDon">打开LED</string>
<string name="LEDoff">关闭LED</string>
</resources>

上面的”打开LED”等资源，就是用在按钮上显示出来的字符串

经过上面的修改，现在程序界面上，已经有如下效果了

鼠标右键工程名>Run as > Android application 运行程序。

4、加入按钮对应的动作

“打开LED”按扭：调用JNI的IOCTLVIB(VIB_ON);

“关闭LED”按钮：调用JNI的 IOCTLVIB(VIB_OFF);

操作：

在LEDAPP > src > com.auly.control > vibrator.java文件

package com.auly.control;
/**定义头文件*/
import android.widget.TextView;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.util.Log;
import android.app.Activity;
import android.os.Bundle;
public class vibrator extends Activity {
    /** 定义变量 */
    public   static   final   int   VIB_ON = 0x11;   
    public   static   final   int   VIB_OFF = 0x22;
    vibClass mvibClass;/**定义类*/
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 /**----------------初始化------------- */       
            mvibClass = new vibClass();/*声明类*/
            mvibClass.Init(); //调用JNI库里的初始化函数
 /**----------------按钮：打开LED------------- */             
     Button btn1 = (Button)findViewById(R.id.led_on);/*这里用到的ID，就是在main.xml里定义的 led_on*/ 
     btn1.setOnClickListener(new View.OnClickListener() 
            {
                public void onClick(View v) /**当按钮按下*/
                {
                    mvibClass.IOCTLVIB(VIB_ON);
                }
            });
/**----------------按钮：关闭LED------------- */ 
            Button btn2 = (Button)findViewById(R.id.led_off);/*声明按钮,id main.xml里有定义*/
            btn2.setOnClickListener(new View.OnClickListener() 
            {
                public void onClick(View v) /**当按钮按下*/
                {
                    mvibClass.IOCTLVIB(VIB_OFF);
                }
            });
    }
}

如果在保存时遇到说 save problems，无法保存，请先复制上面的代码，然后，关闭vibrator.java，提示保存时选不保存，然后在左边资源窗中再次双击打开该文件，把几日才复制下来的内容，粘贴上去，一般就能正常保存，不知道是不是Eclipse的不稳定造成的。

5、添加类vibClass

鼠标右键com.auly.control > new > Class

填参数：

Finish后，在/src/com/auly/control/得到如下的类文件

vibClass.java

修改如下

package com.auly.control;
/*Class for Vibrator --peter*/
public class vibClass {
    static {
        System.loadLibrary("vib-jni");/*加载JNI库*/
    }
    /*声明 函数*/
    public static native String stringFromJNI();/*输出字符串
    对应于JNI里面的
    jstring Java_com_auly_control_vibClass_stringFromJNI( JNIEnv* env,jobject thiz )
    */
    public static native int Init();/*初始化函数，对应于JNI里面的
                                   jint Java_com_auly_control_vibClass_Init( JNIEnv*  env )
                                    */
    public static native int IOCTLVIB(int controlcode);
                                    /*IO CTRL 接口
                                     * 对应于JNI里的
 jint Java_com_auly_control_vibClass_IOCTLVIB( JNIEnv*  env, jobject  thiz, jint controlcode )
 */
}

三、 编译运行

鼠标右键工程名，弹出菜单，选择 Run as > Android Application 就可以看到编译过程，编译完成后，会自动调用android模拟器，看到如下效果

安装到开发板：

在C:/LEDSJNI目录下，会看到bin文件夹，里面的LEDAPP.apk就是这个程序的安装文件，可以把它安装的开发板上，运行本程序，看控制开发板上的LED灯的效果。

步骤：

1、开发板上跑的kenel就已经把了LED驱动编译在里面了，

可以参考《android驱动例子(LED灯控制)》

2、开发板android跑起来后，PC机打开串口工具例如DNW，打开与开发板连接的COM口，然后敲打回车，就会在终端里看到“#”并有光标，表面进入了开发板的命令行终端，

输入命令：

#chmod 777 /dev/vib 

      这是为了使得vib这个节点可以被我们写的JNI操作，不然会open失败的，因为APK安装的JNI模块，权限不够，这个节点是我们的LED驱动生成的控制节点。

也可以在android文件系统yaffs编译时，通过init.rc 文件来实现这个操作，就是在该文件里随便一行，写上面的命令行，启动时会自动执行！这样就不用手动的改变该节点的属性了。

3、拷贝LEDAPP.apk到开发板上，通过安装工具把它安装到开发板上，如果不会安，可以GOOGLE一下，

4、运行程序，就能按程序上的近钮来控制开发板上的LED亮灭了！

Android中使用JNI七个步骤:

1.创建一个android工程

2.JAVA代码中写声明native 方法 public native String helloFromJNI();

3.用javah工具生成头文件

4. 创建jni目录,引入头文件,根据头文件实现c代码

5.编写Android.mk文件

6.Ndk编译生成动态库

7.Java代码load 动态库.调用native代码

Java调用C进行数据传递

 这里分别传递整形、字符串、数组在C中进行处理。

声明native 方法：

public class DataProvider {
	// 两个java中的int 传递c 语言 ,  c语言处理这个相加的逻辑,把相加的结果返回给java
	public native int add(int x ,int y);
	
	//把一个java中的字符串传递给c语言, c 语言处理下字符串, 处理完毕返回给java 
	public native String sayHelloInC(String s);

	//把一个java中int类型的数组传递给c语言, c语言里面把数组的每一个元素的值 都增加5, 
	//然后在把处理完毕的数组，返回给java
	public native int[] intMethod(int[] iNum); 
}

以上方法要在C中实现的头文件，头文件可以理解为要在C中实现的方法

其中 JENEnv* 代表的是java环境 , 通过这个环境可以调用java的方法，jobject 表示哪个对象调用了 这个c语言的方法, thiz就表示的是当前的对象

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class cn_itcast_ndk3_DataProvider */

#ifndef _Included_cn_itcast_ndk3_DataProvider
#define _Included_cn_itcast_ndk3_DataProvider
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     cn_itcast_ndk3_DataProvider
 * Method:    add
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_cn_itcast_ndk3_DataProvider_add
  (JNIEnv *, jobject, jint, jint);

/*
 * Class:     cn_itcast_ndk3_DataProvider
 * Method:    sayHelloInC
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_cn_itcast_ndk3_DataProvider_sayHelloInC
  (JNIEnv *, jobject, jstring);

/*
 * Class:     cn_itcast_ndk3_DataProvider
 * Method:    intMethod
 * Signature: ([I)[I
 */
JNIEXPORT jintArray JNICALL Java_cn_itcast_ndk3_DataProvider_intMethod
  (JNIEnv *, jobject, jintArray);

#ifdef __cplusplus
}
#endif
#endif

C代码出了要引用头文件外，还要引入日志信息，以方便在C 中进行调试

//引入头文件
#include "cn_itcast_ndk3_DataProvider.h"
#include <string.h>
//导入日志头文件
#include <android/log.h>
//修改日志tag中的值
#define LOG_TAG "logfromc"
//日志显示的等级
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)

// java中的jstring, 转化为c的一个字符数组
char*   Jstring2CStr(JNIEnv*   env,   jstring   jstr)
{
	 char*   rtn   =   NULL;
	 jclass   clsstring   =   (*env)->FindClass(env,"java/lang/String");
	 jstring   strencode   =   (*env)->NewStringUTF(env,"GB2312");
	 jmethodID   mid   =   (*env)->GetMethodID(env,clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
	 jbyteArray   barr=   (jbyteArray)(*env)->CallObjectMethod(env,jstr,mid,strencode); // String .getByte("GB2312");
	 jsize   alen   =   (*env)->GetArrayLength(env,barr);
	 jbyte*   ba   =   (*env)->GetByteArrayElements(env,barr,JNI_FALSE);
	 if(alen   >   0)
	 {
	  rtn   =   (char*)malloc(alen+1);         //new   char[alen+1]; "\0"
	  memcpy(rtn,ba,alen);
	  rtn[alen]=0;
	 }
	 (*env)->ReleaseByteArrayElements(env,barr,ba,0);  //释放内存

	 return rtn;
}

//处理整形相加
JNIEXPORT jint JNICALL Java_cn_itcast_ndk3_DataProvider_add
  (JNIEnv * env, jobject obj, jint x, jint y){
	//打印 java 传递过来的 jstring ;
	LOGI("log from c code ");
	LOGI("x= %ld",x);
	LOGD("y= %ld",y);
	return x+y;
}

//处理字符串追加
JNIEXPORT jstring JNICALL Java_cn_itcast_ndk3_DataProvider_sayHelloInC
  (JNIEnv * env, jobject obj, jstring str){

	char* p =  Jstring2CStr(env,str);
	LOGI("%s",p);
	char* newstr = "append string";

	//strcat(dest, sorce) 把sorce字符串添加到dest字符串的后面
	LOGI("END");
	return (*env)->NewStringUTF(env, strcat(p,newstr));
}

//处理数组中的每一个元素
JNIEXPORT jintArray JNICALL Java_cn_itcast_ndk3_DataProvider_intMethod
  (JNIEnv * env, jobject obj, jintArray arr){
    // 1.获取到 arr的大小

    int len = (*env)->GetArrayLength(env, arr);
    LOGI("len=%d", len);

    if(len==0){
    	return arr;
    }
    //取出数组中第一个元素的内存地址
    jint* p = (*env)-> GetIntArrayElements(env,arr,0);
    int i=0;
    for(;i<len;i++){
    	LOGI("len=%ld", *(p+i));//取出的每个元素
    	*(p+i) += 5; //取出的每个元素加五
    }
    return arr;
}

编写Android.mk文件

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := Hello
LOCAL_SRC_FILES := Hello.c 
#增加 log 函数对应的log 库  liblog.so  libthread_db.a
LOCAL_LDLIBS += -llog

include $(BUILD_SHARED_LIBRARY)

 Java代码load 动态库.调用native代码

static{
		System.loadLibrary("Hello");
	}
	DataProvider dp;
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        dp = new DataProvider();
    }
    
    //add对应的事件
    public void add(View view){
    	//执行C语言处理数据
    	int result = dp.add(3, 5);
    	Toast.makeText(this, "相加的结果"+ result, 1).show();	
    }

C中回调java方法

声明native 方法：

public class DataProvider{
	public native void callCcode();
	public native void callCcode1();
	public native void callCcode2();
	
	///C调用java中的空方法  
	public void helloFromJava(){
		System.out.println("hello from java ");
	}
	//C调用java中的带两个int参数的方法
	public int Add(int x,int y){
		System.out.println("相加的结果为"+ (x+y));
		return x+y;
	}
	//C调用java中参数为string的方法
	public void printString(String s){
		System.out.println("in java code "+ s);
	}
}

头文件可以用jdk自带的javah进行自动生成，使用javap -s可以获取到方法的签名。

C代码实现回调需要三个步骤：首先要要获取到 某个对象 , 然后获取对象里面的方法  ,最后 调用这个方法  .

在网上有很多关于讲mdev的自动挂载基本上都是一个版本，经过测试自动挂载确实可行，但是关于自动卸载mdev似乎不能很好的支持，经过修改已经可以做到与udev的效果相似。不能在挂载的目录中进行热插拔，否则会出现问题，不过此问题在下次插入U盘时不会造成影响，可能对U盘有损坏。

本文介绍了mdev与udev两种方法来实现自动挂载，读者可根据需要任选其一即可。

        首先介绍一下mdev与udev之间的关系：

        mdev是busybox中的一个udev管理程序的一个精简版，他也可以实现设备节点的自动创建和设备的自动挂载，只是在实现的过程中有点差异，在发生热插拔时间的时候，mdev是被hotplug直接调用，这时mdev通过环境变量中的 ACTION 和 DEVPATH，来确定此次热插拔事件的动作以及影响了/sys中的那个目录。接着会看看这个目录中是否有“dev”的属性文件，如果有就利用这些信息为这个设备在/dev 下创建设备节点文件。

/***********************************************************************************************************************************************************************************/

1.mdev支持

①用busybox制作根文件系统的时候，要选择支持mdev机制

Linux System Utilities  --->   
           [*] mdev      
           [*]   Support /etc/mdev.conf
           [*]     Support command execution at device addition/removal

②在文件系统/etc/init.d/rsC文件中添加如下内容

Vi  /etc/init.d/rcS
        mount -t tmpfs mdev /dev
        mount -t sysfs sysfs /sys
        mkdir /dev/pts
        mount -t devpts devpts /dev/pts

        echo /sbin/mdev>/proc/sys/kernel/hotplug
        mdev –s

这些语句的添加在busybox的/doc/mdev.txt中可以找到。

 

③添加对热插拔事件的响应，实现U盘和SD卡的自动挂载。

Vi /etc/mdev.conf
       sd[a-z][0-9]      0:0 666        @/etc/mdev/udisk_insert                        

         sd[a-z]                   0:0 666          $/etc/mdev/udisk_remove

红色部分，是一个脚本，脚本内容可以根据我们的需要定制，可以实现挂载，卸载或其他一些功能。

注：@表示是在插入（创建设备结点）后执行后面的脚本，$表示在拔出（删除设备结点）前执行后面的脚本。

如下是自动挂载和卸载的脚本名称及其内容：

#!/bin/sh

if [ -d /sys/block/*/$MDEV ]  ; then

  mkdir -p /media/$MDEV

  mount /dev/$MDEV /media/$MDEV 

fi

根文件系统中的etc/mdev/udisk_remove文件内容:

        #!/bin/sh

        umount -l /media/$MDEV

        rm -rf /media/$MDEV

 

        #!/bin/sh

        umount -l /media/sd*

        rm -rf /media/sd*

修改为红色部分后能够自动挂载

以上两个脚本需要可执行权限：chmod +x  /etc/mdev/udisk_insert

               chmod +x etc/mdev/udisk_remove

/***********************************************************************************************************************************************************************************/

2.udev支持 

        linux传统上使用静态设备创建的方法，在dev下创建了大量的节点，而不管这些节点相应的硬件设备是否存在。采用udev的方法，系统检测到设备才会去创建这些设备对应的节点。

        这里我们简单的说一下udev的工作原理：

        udev是依赖于sysfs的，当系统中添加一个新的设备后，内核检测到后就会产生一个hotplug event并查找/proc/sys/kernel/hotplug去找出管理设备连接的用户空间程序，若udev已经启动，内核会通知udev去检测sysfs中关于这个新设备的信息并创建设备节点。如/dev/vcs,在/sys/class/tty/vcs/dev存放的是”7:0”，既/dev/vcs的主次设备号。并且udev还会根据/etc/udev/rules.d中的规则文件实现一些相应的功能。

下面我们介绍一下如何实现设备节点的自动创建及u盘或sd卡的自动挂载。

因为文件系统中默认是没有对udev进行支持的，所以我们移植一个udev。

1.下载udev源码udev-100.tar.bz2，并解压

网址：http://www.us.kernel.org/pub/linux/utils/kernel/hotplug

2.交叉编译。

修改makefile,具体修改如下：

        cross = arm-linux-

保存退出。

然后执行命令：make 进行编译，然后执行arm-linux-strip udev udevd udevstart udevinfo udevtest，并拷贝这些文件到目标板根文件/bin目录下面。

3.添加udev的支持

下面三种方法功能相同

        (1)并修改etc/init.d/rcs脚本，然后添加如下命令：

        /bin/mount -t sysfs sysfs /sys 

        /bin/mount -t tmpfs tmpfs /dev

        /bin/udevd --daemon

        /bin/udevstart

        (2)如果linuxrc是二进制文件的话 

        rm /linuxrc

        vi /linuxrc

        添加如下内容

        /bin/mount -t sysfs sysfs /sys

        /bin/mount -t tmpfs tmpfs /dev

        /bin/udevd --daemon

        /bin/udevstart

        exec /sbin/init

        (3)修改/etc/fstab为

        #device mount-point type options dump fsck order

        proc /proc proc defaults 0 0

        tmpfs /tmp tmpfs defaults 0 0

        sysfs /sys sysfs defaults 0 0

        tmpfs /dev tmpfs defaults 0 0

        修改/etc/init.d/rcs,添加如下内容

/bin/udevd --daemon

/bin/udevstart

        重新启动系统，文件系统就能够自动创建节点。

 

4.在/etc下创建udev目录

5.在/etc/udev下穿件目录rules.d和文件udev.conf

6.在udev.conf中添加如下内容

# udev.conf

        # the initial syslog(3) priority: "err", "info", "debug" or its

        # numerical equivalent. for runtime debugging, the daemons internal

        # state can be changed with: "udevcontrol log_priority=<value>".

        udev_log="err"

7.在rules.d下创建规则文件

如实现u盘自动挂载

        vim 11-add-usb.rules

添加如下内容

        action!="add",goto="farsight"

        kernel=="sd[a-z][0-9]",run+="/sbin/mount-usb.sh %k"

        label="farsight"

这个文件中action后是说明是什么事件，kernel后是说明是什么设备比如sda1，mmcblk0p1等，run这个设备插入后去执行哪个程序%k是传入这个程序的参数，这里%k=kernel的值也就是sda1等http://www.woaidiannao.com。

在/sbin/下创建mount-usb.sh文件添加如下内容 计算机

        #!/bin/sh

        /bin/mount -t vfat /dev/$1 /tmp

        sync

修改文件权限为其添加可执行的权限。

这样就实现了u盘的自动挂载，下面附上u盘的卸载规则文件和sd卡的文件

usb卸载

11-add-remove.rules

        action !="remove",goto="farsight"

        subsystem!="block",goto="farsight"

        kernel=="sd[a-z][0-9]",run+="/sbin/umount-usb.sh"

        label="farsight"

umount-usb.sh

        #!/bin/sh

        sync

        umount /tmp/

sd卡挂载

12-add-sd.rules

action!="add",goto="farsight"

        kernel=="mmcblk[0-9]p[0-9]",run+="/sbin/mount-sd.sh %k"

        label="farsight"

mount-sd.sh

        #!/bin/sh

        /bin/mount -t vfat /dev/$1 /tmp

        sync

 

sd卸载

12-remove-sd.rules

        action !="remove",goto="farsight"

        subsystem!="block",goto="farsight"

        kernel=="mmcblk*",run+="/sbin/umount-sd.sh"

        label="farsight"

umount-sd.sh

        #!/bin/sh

        sync

        /bin/umount /tmp/

   写Linux 设备驱动程序的时候，很多时候都是利用mknod 命令手动创建设备节点，mdev可以用来在模块加载-- insmod-- 的时候自动在/dev 目录下创建相应设备节点，并在卸载模块-- rmmod --时删除该节点。
   内核同时提供了class_create( …) 函数，可以用它来创建一个类，这个类存放于sysfs 下面，一旦创建好了这个类，再调用device_create(…) 函数来在/dev 目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev 会自动响应device_create( …) 函数，去/sysfs 下寻找对应的类从而创建设备节点。
举例如下(只是把关键的函数说明下)：

1. #include <linux/module.h>
   
2. #include <linux/fs.h>
   
3. #include <linux/string.h>
   
4. #include <linux/init.h>
   
5. #include <linux/platform_device.h>
   
6. #include <linux/interrupt.h>
   
7. #include <linux/rtc.h>
   
8. #include <linux/bcd.h>
   
9. #include <linux/clk.h>
   
10. #include <linux/device.h>
    
11. 
    
12. MODULE_LICENSE("Dual BSD/GPL");
    
13. 
    
14. static struct class *firstdrv_class;
    
15. static struct class_device *firstdrv_class_dev;
    
16. 
    
17. 
    
18. static int first_drv_open(struct inode *inode, struct file *file)
    
19. {
    
20.     printk("first_drv_open\n");
    
21.     
    
22.     return 0;
    
23. }
    
24. 
    
25. static ssize_t first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
    
26. {
    
27.     printk("first_drv_write\n");
    
28.     
    
29.     return 0;
    
30. }
    
31. 
    
32. static struct file_operations first_drv_fops =
    
33. {
    
34.     .owner = THIS_MODULE,
    
35.     .open = first_drv_open,
    
36.     .write = first_drv_write,
    
37. };
    
38. 
    
39. int major;
    
40. static int first_drv_init(void)
    
41. {
    
42.     printk("Hello world!\n");
    
43.     major = register_chrdev(0, "first_drv", &first_drv_fops);
    
44.     firstdrv_class = class_create(THIS_MODULE, "firstdrv");
    
45.     firstdrv_class_dev = class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz");
    
46.     return 0;
    
47. }
    
48. 
    
49. static void first_drv_exit(void)
    
50. {
    
51.     printk("Bye, hello world!\n");
    
52.     unregister_chrdev(major, "first_drv");
    
53.     class_device_unregister(firstdrv_class_dev);
    
54.     class_destroy(firstdrv_class);
    
55. }
    
56. 
    
57. module_init(first_drv_init);
    
58. module_exit(first_drv_exit);
    

复制代码

附上Makefile 文件：

1. KERNELDIR = /opt/linux-2.6.22.6/
   
2.     # The current directory is passed to sub-makes as argument
   
3. PWD := $(shell pwd)
   
4. CC =arm-linux-gcc
   
5. obj-m := hello.o
   
6. modules:
   
7.     $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
   
8. clean:
   
9.     rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions
   
10. .PHONY: modules modules_install clean
    

复制代码

进入目录，make

生成 hello.ko 文件，拷贝到nfs目录，发现insmod 成功，但是没有自动创建 /dev/xyz设备。

1. # insmod hello.ko
   
2. Hello world!
   
3. # lsmod
   
4. hello 2188 0 - Live 0xbf000000
   
5. # cat /proc/devices
   
6. Character devices:
   
7.   1 mem
   
8.   2 pty
   
9.   3 ttyp
   
10.   4 /dev/vc/0
    
11.   4 tty
    
12.   4 ttyS
    
13.   5 /dev/tty
    
14.   5 /dev/console
    
15.   5 /dev/ptmx
    
16.   6 lp
    
17.   7 vcs
    
18. 10 misc
    
19. 13 input
    
20. 29 fb
    
21. 90 mtd
    
22. 99 ppdev
    
23. 128 ptm
    
24. 136 pts
    
25. 180 usb
    
26. 189 usb_device
    
27. 204 s3c2410_serial
    
28. 252 first_drv
    
29. 253 usb_endpoint
    
30. 254 rtc
    
31. 
    
32. Block devices:
    
33.   1 ramdisk
    
34.   7 loop
    
35.   8 sd
    
36. 31 mtdblock
    
37. 65 sd
    
38. 66 sd
    
39. 67 sd
    
40. 68 sd
    
41. 69 sd
    
42. 70 sd
    
43. 71 sd
    
44. 128 sd
    
45. 129 sd
    
46. 130 sd
    
47. 131 sd
    
48. 132 sd
    
49. 133 sd
    
50. 134 sd
    
51. 135 sd
    
52. # ls /dev/xyz
    
53. ls: /dev/xyz: No such file or directory
    

复制代码

查看busybox里面的 mdev.txt 文件，于是在 /etc/init.d/rcS里面增加如下命令，蓝色部分（个人觉得 mount -t proc proc /proc 这条可以不用）：

#!/bin/sh
ifconfig eth0 192.168.1.133
ifconfig lo up
mount -a
mount -t proc proc /proc
mount -t sysfs sysfs /sys
echo /sbin/mdev > /proc/sys/kernel/hotplug
mdev -s

然后
reboot，重新insmod 相应的.ko文件

1. # cd /mnt/
   
2. # insmod hello.ko
   
3. Hello
   
4. # lsmod
   
5. hello 2188 0 - Live 0xbf000000
   
6. # cat /proc/devices
   
7. Character devices:
   
8.   1 mem
   
9.   2 pty
   
10.   3 ttyp
    
11.   4 /dev/vc/0
    
12.   4 tty
    
13.   4 ttyS
    
14.   5 /dev/tty
    
15.   5 /dev/console
    
16.   5 /dev/ptmx
    
17.   6 lp
    
18.   7 vcs
    
19. 10 misc
    
20. 13 input
    
21. 29 fb
    
22. 90 mtd
    
23. 99 ppdev
    
24. 128 ptm
    
25. 136 pts
    
26. 180 usb
    
27. 189 usb_device
    
28. 204 s3c2410_serial
    
29. 252 first_drv
    
30. 253 usb_endpoint
    
31. 254 rtc
    
32. 
    
33. Block devices:
    
34.   1 ramdisk
    
35.   7 loop
    
36.   8 sd
    
37. 31 mtdblock
    
38. 65 sd
    
39. 66 sd
    
40. 67 sd
    
41. 68 sd
    
42. 69 sd
    
43. 70 sd
    
44. 71 sd
    
45. 128 sd
    
46. 129 sd
    
47. 130 sd
    
48. 131 sd
    
49. 132 sd
    
50. 133 sd
    
51. 134 sd
    
52. 135 sd
    
53. # ls /dev/xyz
    
54. /dev/xyz
    

复制代码

注意上面的蓝色字体部分，自动创建成功。

echo /sbin/mdev >/proc/sys/kernel/hotplug 是当有热插拔事件产生时，内核就会调用位于/sbin目录的mdev。这时mdev通过环境变量中的 ACTION 和DEVPATH，（这两个变量是系统自带的）来确定此次热插拔事件的动作以及影响了/sys中的那个目录。接着会看看这个目录中是否有“dev”的属性文件，如果有就利用这些信息为这个设备在/dev 下创建设备节点文件。

驱动里，那2个函数只是在sysfs里建信息；需要hotplug的mdev根据这些信息来创建节点