Android7 Led闪光灯的控制 从底层到上层

最新推荐文章于 2024-08-05 11:21:16 发布
最新推荐文章于 2024-08-05 11:21:16 发布
阅读量4.3k 收藏 25
点赞数 4
分类专栏： IMX6Q-SDB Android7.1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shui1025701856/article/details/78480776
版权
Android Version:v7.1.1
Linux Version:V4.1.15
Hardware:IMX6Q

1.底层led驱动程序,为上层提供/dev/led

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/fs.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/miscdevice.h>
#include <linux/platform_device.h>
#include <asm/uaccess.h>

#define DRIVER_NAME "flash_led"
#define DEVICE_NAME "flash_led"
#define MISC_NAME   "led"

#define MISC_IOC_MAGIC 'M'
#define LED_ON _IO(MISC_IOC_MAGIC, 0x01)
#define LED_OFF _IO(MISC_IOC_MAGIC, 0x02)

struct flash_led_data {
	unsigned int gpio;
};
static int gpio = 0;

static long flash_led_misc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg){
	
	if(_IOC_TYPE(cmd)!= MISC_IOC_MAGIC)
	  return -EFAULT;

	switch(cmd){
		case LED_ON:
			gpio_set_value(gpio, 1);
			break;
		case LED_OFF:
			gpio_set_value(gpio, 0);
			break;
		default:
			break;
	}

	return 0;
}

static const struct file_operations flash_led_misc_fops = {
	.owner = THIS_MODULE,
	.unlocked_ioctl = flash_led_misc_ioctl,
};

static struct miscdevice flash_led_misc_device = {
	.minor = MISC_DYNAMIC_MINOR,
	.name  = MISC_NAME,
	.fops  = &flash_led_misc_fops,
};


static int flash_led_probe(struct platform_device *pdev){
	struct device_node *np = pdev->dev.of_node;
	struct flash_led_data *data;
	int ret = 0;

	if(np == NULL){
		return 0;//void the probe exec twice
	}
	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if(data == NULL)
		return -ENOMEM;

	data->gpio = of_get_named_gpio(np,"gpios", 0);
	gpio = data->gpio;

	ret = devm_gpio_request_one(&pdev->dev, data->gpio,GPIOF_OUT_INIT_LOW,NULL);
	if(ret < 0)
	  printk("failed to request flash led gpio\n");
	misc_register(&flash_led_misc_device);


	return 0;
}

static int flash_led_remove(struct platform_device *pdev){
	struct device_node *np = pdev->dev.of_node;
	if(np == NULL)
	  return 0;

	misc_deregister(&flash_led_misc_device);
	return 0;
}

static int flash_led_suspend(struct platform_device *pdev, pm_message_t state){

	return 0;
}

static int flash_led_resume(struct platform_device *pdev)
{
	return 0;
}

static void flash_led_device_release(struct device *pdev){

	return ;
}

static struct of_device_id flash_dt_ids[] = {
	{ .compatible = "flash-leds"},
	{}
};

MODULE_DEVICE_TABLE(of, flash_dt_ids);

static struct platform_driver flash_led_driver = {
	.probe  = flash_led_probe,
	.remove = flash_led_remove,
	.driver = {
		.name  = DRIVER_NAME,
		.owner = THIS_MODULE,
		.of_match_table = of_match_ptr(flash_dt_ids),
	},
	.suspend = flash_led_suspend,
	.resume  = flash_led_resume,
};


static struct platform_device flash_led_device = {
	.name = DEVICE_NAME,
	.dev = {
		.release = flash_led_device_release,
	}
};

static int __init flash_led_init(void){
	platform_device_register(&flash_led_device);
	platform_driver_register(&flash_led_driver);
	return 0;
}

static void __exit flash_led_exit(void){
	platform_driver_unregister(&flash_led_driver);
	platform_device_unregister(&flash_led_device);
}

module_init(flash_led_init);
module_exit(flash_led_exit);

MODULE_LICENSE("GPL");

--------------------------------------------------------------------
dts里配置gpio 为led 闪光灯
leds {

      compatible = "flash-leds";
      gpios = <&gpio1 19 0>;
};

MX6QDL_PAD_SD1_DAT2__GPIO1_IO19 0x80000000   /*flash led*/

2.HAL层,增加模块接口,以访问驱动程序

主要是操作驱动程序,open,ioctl,close
生成led.default.so 在system/lib/hw/目录下
在modules目录新建led目录
hardware/libhardware/modules/led/
led.c

#define LOG_TAG "LedStub"

#include <hardware/hardware.h>
#include <hardware/led.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <stdio.h>

#define MISC_IOC_MAGIC 'M'
#define LED_ON  _IO(MISC_IOC_MAGIC, 0x01)
#define LED_OFF _IO(MISC_IOC_MAGIC, 0x02)
#define DEVICE_NAME "/dev/led"

int led_device_close(struct hw_device_t* device){
	struct led_control_device_t *led_dev = (struct led_control_device_t*)device;
	
	if(led_dev){
	  close(led_dev->fd);
	  free(led_dev);
	}

	return 0;
}

int led_on(struct led_control_device_t *dev, int led){
	ALOGI("LED set %d on", led);
	ioctl(dev->fd, LED_ON, NULL);
	return 0;
}

int led_off(struct led_control_device_t *dev, int led){
	ALOGI("LED set %d off", led);
	ioctl(dev->fd, LED_OFF, NULL);
	return 0;
}

static int led_device_open(const hw_module_t* module, const char* name,
			hw_device_t** device){
	struct led_control_device_t *dev;

	dev = calloc(1, sizeof(struct led_control_device_t));
	if(!dev){
		ALOGE("led device open error");	
		return -ENOMEM;
	}

	dev->common.tag     = HARDWARE_DEVICE_TAG;
	dev->common.version = 0;
	dev->common.module  = (struct hw_module_t *)module;
	dev->common.close   = led_device_close;

	dev->set_on  = led_on;
	dev->set_off = led_off;


	dev->fd = open(DEVICE_NAME, O_RDWR);
	if(dev->fd <0){
		ALOGE("open /dev/led error");
	}else
	  ALOGI("open /dev/led success");
	
	*device = &dev->common;
	return 0;
}

static struct hw_module_methods_t led_module_methods = {
	.open = led_device_open,
};

struct led_module_t HAL_MODULE_INFO_SYM = {
	.common = {
		.tag = HARDWARE_MODULE_TAG,
		.version_major = 1,
		.version_minor = 0,
		.id = LED_HARDWARE_MODULE_ID,
		.name = "LED FLASH HW HAL",
		.author = "The Android Open Source Project",
		.methods = &led_module_methods,
	},
};
-------------------------------------------------
led.h
hardware/libhardware/include/hardware/led.h
#ifndef LED_H
#define LED_H

#include <hardware/hardware.h>
#include <fcntl.h>
#include <errno.h>
#include <cutils/log.h>
#include <cutils/atomic.h>

#define LED_HARDWARE_MODULE_ID "led"

struct led_module_t {
	struct hw_module_t common;
};

struct led_control_device_t {
	struct hw_device_t common;
	int fd;

	int (*set_on)(struct led_control_device_t *dev, int led);
	int (*set_off)(struct led_control_device_t *dev, int led);

};
#endif
------------------------------------------------------------
Android.mk
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := led.default

LOCAL_MODULE_RELATIVE_PATH := hw
LOCAL_C_INCLUDES := hardware/libhardware
LOCAL_SRC_FILES := led.c
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_MODULE_TAGS := optional

include $(BUILD_SHARED_LIBRARY)

3.JNI层,编写JNI方法,在应用程序框架层提供Java接口访问硬件

frameworks/base/services/core/jni/com_android_server_led_LedService.cpp
生成文件打包进system/lib/libandroid_servers.so
Android系统初始化时,会自动加载JNI方法
01-06 06:45:45.611   520   520 I SystemServer: Led Service
01-06 06:45:45.611   520   520 I LedService: Go to get Led Stub
01-06 06:45:45.611   520   520 I LedStub : led jni init......
01-06 06:45:45.615   520   520 I LedStub : Led JNI: led stub found.

#define LOG_TAG "LedStub"

#include "jni.h"
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"

#include <utils/misc.h>
#include <utils/Log.h>
#include <hardware/hardware.h>
#include <hardware/led.h>

#include <stdio.h>

namespace android {
	
	struct led_control_device_t *sLedDevice = NULL;

	static jboolean led_on(JNIEnv *env, jobject clazz, jint led){
		ALOGI("LedService JNI:led_on");
		if(sLedDevice==NULL){
			ALOGE("LedService JNI: led_on() is invoked");
			return -1;
		}else
		  return sLedDevice->set_on(sLedDevice,led);
	}

	static jboolean led_off(JNIEnv *env, jobject clazz, jint led){
		ALOGI("LedService JNI:led_off");
		if(sLedDevice==NULL){
			ALOGE("LedService JNI: led_off() is invoked");
			return -1;
		}else
		  return sLedDevice->set_off(sLedDevice,led);
	}
	static inline int led_control_open(const struct hw_module_t *module, struct led_control_device_t** device){
		return module->methods->open(module, LED_HARDWARE_MODULE_ID, 
					(struct hw_device_t**)device);
	}

	static jboolean led_init(JNIEnv *env, jclass clazz){
		led_module_t* module;
		ALOGI("led jni init......");
		if(hw_get_module(LED_HARDWARE_MODULE_ID, (const struct hw_module_t**)&module) == 0){
			ALOGI("Led JNI: led stub found.");
			if(led_control_open(&module->common, &sLedDevice) == 0){
				ALOGI("JNI: led device is open");
				return 0;
			}
			ALOGE("LED JNI: failed to open led device");
			return -1;
		}
		ALOGE("LED JNI: failed to get led stub module");
		return -1;
	}

	static const JNINativeMethod method_table[] = {
		{"init_native","()Z", (void*)led_init},
		{"led_on", "(I)Z", (void*)led_on},
		{"led_off", "(I)Z", (void*)led_off},
	};

	int register_android_server_LedService(JNIEnv *env){
	
		return jniRegisterNativeMethods(env, "com/android/server/led/LedService", method_table, NELEM(method_table));
	}
};

--- a/frameworks/base/services/core/jni/onload.cpp
+++ b/frameworks/base/services/core/jni/onload.cpp
@@ -46,6 +46,7 @@ int register_android_server_tv_TvInputHal(JNIEnv* env);
 int register_android_server_PersistentDataBlockService(JNIEnv* env);
 int register_android_server_Watchdog(JNIEnv* env);
 int register_android_server_HardwarePropertiesManagerService(JNIEnv* env);
+int register_android_server_LedService(JNIEnv* env);
 };
 
 using namespace android;
@@ -87,7 +88,7 @@ extern "C" jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
     register_android_server_PersistentDataBlockService(env);
     register_android_server_Watchdog(env);
     register_android_server_HardwarePropertiesManagerService(env);
-
+       register_android_server_LedService(env);

4.framework层,应用程序框架层,增加硬件服务接口

jni在注册方法时用到com/android/server/led/LedService
所以在frameworks/base/services/core/java/com/android/server/目录下新建led文件夹
# ls frameworks/base/services/core/java/com/android/server/led/
LedService.java
----------------------------------------------------------------------------
在Android系统中，硬件服务一般是运行在一个独立的进程中为各种应用程序提供服务。
因此，调用这些硬件服务的应用程序与这些硬件服务之间的通信需要通过代理来进行
创建aidl文件来描述通信接口

frameworks/base/core/java/android/os/ILedService.aidl
package android.os;

/**
 * {@hide}
 */
interface ILedService {
	boolean setOn(); 
	boolean setOff();
}
--------------------------------------------------------
frameworks/base/services/core/java/com/android/server/led/LedService.java
package com.android.server.led;

import android.util.Config;
import android.util.Log;
import android.content.Context;
import android.os.Binder;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.IBinder;
import android.os.ILedService;

public final class LedService extends ILedService.Stub{

	private Context mContext;

	public LedService(Context context){
		super();
		mContext = context;
		Log.i("LedService","Go to get Led Stub");
		init_native();
	}
	
	public boolean setOn(){
		Log.i("LedService","Led On");
		return led_on(0);
	}

	public boolean setOff(){
		Log.i("LedService","Led Off");
		return led_off(1);
	}

	private static native boolean init_native(); //和jni里面的对应
	private static native boolean led_on(int led);
	private static native boolean led_off(int led);
}

--- a/frameworks/base/services/core/jni/Android.mk
+++ b/frameworks/base/services/core/jni/Android.mk
@@ -36,6 +36,7 @@ LOCAL_SRC_FILES += \
     $(LOCAL_REL_DIR)/com_android_server_UsbHostManager.cpp \
     $(LOCAL_REL_DIR)/com_android_server_VibratorService.cpp \
     $(LOCAL_REL_DIR)/com_android_server_PersistentDataBlockService.cpp \
+       $(LOCAL_REL_DIR)/com_android_server_led_LedService.cpp \


---------------------------------------------------------------------------
在frameworks/base里增加对aidl的编译项
--- a/frameworks/base/Android.mk
+++ b/frameworks/base/Android.mk
@@ -218,6 +218,7 @@ LOCAL_SRC_FILES += \
        core/java/android/nfc/INfcFCardEmulation.aidl \
        core/java/android/nfc/INfcUnlockHandler.aidl \
        core/java/android/nfc/ITagRemovedCallback.aidl \
+       core/java/android/os/ILedService.aidl \

编译后会在out目录下产生ILedService.java文件
out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/os/ILedService.java

5.通过Manager调用Service

Manager管理service,在注册服务时候就实例化一个Manager,App获取服务getService也就获取
了这个对象

frameworks/base/core/java/android/os/LedManager.java
package android.os;
import android.content.Context;
import android.os.Binder;
import android.os.Bundle;
import android.os.Parcelable;
import android.os.ParcelFileDescriptor;
import android.os.Process;
import android.os.RemoteException;
import android.os.Handler;
import android.os.Message;
import android.os.ServiceManager;
import android.util.Log;
import android.os.ILedService;

public class LedManager{

	private static final String TAG="LedManager";
	private ILedService mLedService;
	private Context mContext;

	public LedManager(Context context, ILedService service){
			mContext = context;
			mLedService = service;
	}

	public boolean LedOn(){
		try{
			return mLedService.setOn();
		}catch(RemoteException e){
			Log.e(TAG,"RemoteException in LedManager Ledon",e);
			return false;
		}
	}

	public boolean LedOff(){
		try{
			return mLedService.setOff();
		}catch(RemoteException e){
			Log.e(TAG,"RemoteException in LedManager Ledoff",e);
			return false;
		}
	}
}

6.添加注册服务,addService开机服务就可以启动

通过service list 命令查看服务是否启动

# service list | grep led                                          
35    led: [android.os.ILedService]

--- a/frameworks/base/services/java/com/android/server/SystemServer.java
+++ b/frameworks/base/services/java/com/android/server/SystemServer.java
@@ -103,6 +103,7 @@ import com.android.server.usage.UsageStatsService;
 import com.android.server.vr.VrManagerService;
 import com.android.server.webkit.WebViewUpdateService;
 import com.android.server.wm.WindowManagerService;
+import com.android.server.led.LedService;
 
 import dalvik.system.VMRuntime;
 
@@ -516,6 +517,7 @@ public final class SystemServer {
      */
     private void startOtherServices() {
         final Context context = mSystemContext;
+               LedService led = null;
         VibratorService vibrator = null;
         IMountService mountService = null;
         NetworkManagementService networkManagement = null;
@@ -987,6 +989,15 @@ public final class SystemServer {
                     }
                     Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
                 }
+                               
+                               try{
+                                       Slog.i(TAG,"Led Service");
+                                       led = new LedService(context);
+                                       ServiceManager.addService(Context.LED_SERVICE, led);
+                                       Slog.i(TAG,"Led Service-----");
+                               }catch(Throwable e){
+                                       Slog.e(TAG,"Failure starting LedService", e);
+                               }

--- a/frameworks/base/core/java/android/content/Context.java
+++ b/frameworks/base/core/java/android/content/Context.java
@@ -3431,6 +3431,15 @@ public abstract class Context {
     public static final String SERIAL_SERVICE = "serial";
 
     /**
+     * Use with {@link #getSystemService} to retrieve a {@link
+     * android.os.LedManager} for access to led ports.
+     *
+     * @see #getSystemService
+     *
+     * @hide
+     */
+    public static final String LED_SERVICE = "led";

注册服务
--- a/frameworks/base/core/java/android/app/SystemServiceRegistry.java
+++ b/frameworks/base/core/java/android/app/SystemServiceRegistry.java
@@ -127,6 +127,8 @@ import android.view.accessibility.AccessibilityManager;
 import android.view.accessibility.CaptioningManager;
 import android.view.inputmethod.InputMethodManager;
 import android.view.textservice.TextServicesManager;
+import android.os.LedManager;
+import android.os.ILedService;
 
 import java.util.HashMap;
 
@@ -480,6 +482,14 @@ final class SystemServiceRegistry {
                 return new SerialManager(ctx, ISerialManager.Stub.asInterface(b));
             }});
 
+        registerService(Context.LED_SERVICE, LedManager.class,
+                new CachedServiceFetcher<LedManager>() {
+            @Override
+            public LedManager createService(ContextImpl ctx) {
+                IBinder b = ServiceManager.getService(Context.LED_SERVICE);
+                return new LedManager(ctx, ILedService.Stub.asInterface(b));
+            }});
+

7.更新API

make update-api -j16

8.修改节点权限

Android在Selinux下要获取对内核节点访问的权限,需要修改.te文件

1)为/dev/led节点定义一个名字led_device

--- a/device/fsl/imx6/sepolicy/file_contexts
+++ b/device/fsl/imx6/sepolicy/file_contexts
@@ -8,6 +8,7 @@
 /dev/ttymxc[0-9]*               u:object_r:tty_device:s0
 /dev/ttyUSB[0-9]*               u:object_r:tty_device:s0
 /dev/mma8x5x                    u:object_r:sensors_device:s0
+/dev/led                        u:object_r:led_device:s0

2)将led_device声明为dev_type

--- a/device/fsl/imx6/sepolicy/device.te
+++ b/device/fsl/imx6/sepolicy/device.te
@@ -1,2 +1,3 @@
 type caam_device, dev_type;
 type pxp_device, dev_type;
+type led_device,dev_type;

3)修改读写权限

--- a/device/fsl/imx6/sepolicy/system_server.te
+++ b/device/fsl/imx6/sepolicy/system_server.te
@@ -4,3 +4,4 @@ allow system_server system_data_file:file {relabelto rw_file_perms};
 allow system_server system_data_file:dir {relabelto rw_dir_perms};
 allow system_server kernel:system { syslog_read };
 allow system_server debugfs_tracing:file { write };
+allow system_server led_device:chr_file { open read write ioctl };

4)修改linux下节点自身的权限

--- a/device/fsl/imx6/etc/ueventd.freescale.rc
+++ b/device/fsl/imx6/etc/ueventd.freescale.rc
@@ -1,3 +1,4 @@
+/dev/led                  0660   system     system

5)增加服务的权限

--- a/system/sepolicy/service_contexts
+++ b/system/sepolicy/service_contexts
@@ -116,6 +116,7 @@ scheduling_policy                         u:object_r:scheduling_policy_service:s
 search                                    u:object_r:search_service:s0
 sensorservice                             u:object_r:sensorservice_service:s0
 serial                                    u:object_r:serial_service:s0
+led                                       u:object_r:led_service:s0

--- a/system/sepolicy/service.te
+++ b/system/sepolicy/service.te
@@ -96,6 +96,7 @@ type rttmanager_service, app_api_service, system_server_service, service_manager
 type samplingprofiler_service, system_server_service, service_manager_type;
 type scheduling_policy_service, system_server_service, service_manager_type;
 type search_service, app_api_service, system_server_service, service_manager_type;
+type led_service, app_api_service, system_server_service, service_manager_type;

9.编译更新系统镜像到emmc

10.android app 测试

将out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/classes.jar里的
android/os/LedManager.class
导入eclipse 的sdk/platforms/android-xx/android.jar包中
的android/os目录

package com.led.ledclient;

import android.os.Bundle;
import android.app.Activity;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.os.LedManager;
public class MainActivity extends Activity implements OnClickListener {
	private Button btOn;
	private Button btOff;
	LedManager ledm;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		btOn = (Button)findViewById(R.id.btOn);
		btOff = (Button)findViewById(R.id.btOff);
		btOn.setOnClickListener(this);
		btOff.setOnClickListener(this);
		
		ledm = (LedManager)getSystemService("led");
		
		
	}
	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.btOn:
			ledm.LedOn();
			break;
		case R.id.btOff:
			ledm.LedOff();
			break;
		default:
			break;
		}
		
	}

	

}
//开Button
01-06 07:40:30.664   520   531 I LedService: Led On
01-06 07:40:30.664   520   531 I LedStub : LedService JNI:led_on
01-06 07:40:30.664   520   531 I LedStub : LED set 0 on
//关Button
01-06 07:40:39.069   520   906 I LedService: Led Off
01-06 07:40:39.069   520   906 I LedStub : LedService JNI:led_off
01-06 07:40:39.069   520   906 I LedStub : LED set 1 off


11.总结

APP调用了LedManager里的LedOn LedOff
LedManager服务通过aidl调用到LedService.java里的setOn setOff
LedService通过jni提供的接口调用led_on led_off
private static native boolean led_on(int led);
private static native boolean led_off(int led);
jni注册的方法表
{"led_on", "(I)Z", (void*)led_on},
{"led_off", "(I)Z", (void*)led_off},
jni层调用 led_on----->return sLedDevice->set_on(sLedDevice,led);
      led_off---->return sLedDevice->set_off(sLedDevice,led);

调用到硬件抽象层led.default.so里的
    dev->set_on  = led_on;
    dev->set_off = led_off;
led_on/led_off通过ioctl调用到驱动调置gpio的高低电平


参考:
http://www.cnblogs.com/hackfun/p/7418902.html
http://blog.csdn.net/baiduluckyboy/article/details/6973015
http://blog.csdn.net/luoshengyang/article/details/6567257



KylinAnAn
关注
专栏目录
android应用:如何控制闪光灯
dailinqing1984的博客
08-06 602
使用camera控制闪光灯 private void setFlashlightEnabled(boolean isEnable) { Camera camera = null; Camera.Parameters parameters = null; //直接开启 camera = Camera.open();
Android驱动入门-Led控制+app+ndk库+底层驱动
weixin_30325971的博客
09-20 371
硬件平台：　FriendlyARM Tiny4412 Cortex-A9 操作系统： UBUNTU 14.04 LTS 时间：2016-09-20 21:56:48 本次实验使用的是 安卓APP + NDK库 + Linux底层驱动。 一、 首先在 Android Studio 上编写APP。 对软件进行布局。 <?xml version="1.0" encoding="...
Linux驱动开发—中断，中断号，中断控制器GIC，中断子系统架构详解
最新发布
weixin_46999174的博客
08-05 1174
函数在 Linux 内核中用于注册中断处理程序。它是设备驱动程序中常用的函数，用于为特定中断向量分配中断处理程序。函数在 Linux 内核中用于注册中断处理程序。它是设备驱动程序中常用的函数，用于为特定中断向量分配中断处理程序。以下是函数的详细介绍和一个与相机设备相关的示例。函数原型参数说明irq: 中断号，表示你要注册的中断向量。handler: 中断处理程序，当指定的中断发生时，系统将调用这个处理程序。flags: 标志，用于指定中断类型和处理选项。常见的标志包括（上升沿触发），（下降沿触发），
android 驱动闪光灯
疾风剑豪
05-15 497
public class ledFlash { Context context; CameraManager mCameraManager; String mCameraID; @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) ledFlash(Context context){ this.c...
BLE 安卓APP控制LED灯的实现
热门推荐
liqinghan的专栏
11-21 2万+
//注：参考AmoMcu源代码修改。 打开APP，检查蓝牙是否打开 BluetoothAdapter mBluetoothAdapter; final BluetoothManager bluetoothManager =(BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);       mBlue
android led闪烁功能,Android如何快速闪烁LED /手电筒
weixin_30404433的博客
05-26 473
您在哪里设置预览显示？Important: Pass a fully initialized SurfaceHolder tosetPreviewDisplay(SurfaceHolder). Without a surface, the camera willbe unable to start the preview.cam.setPreviewDisplay(null);也许您应该尝试这样：...
test-led.zip_android_android 控制闪光灯_android 驱动_android ，项目_测试
09-20
本项目"test-led.zip"专注于在Android平台上实现对闪光灯的底层驱动控制，提供了完整的测试案例，帮助开发者深入理解和实践Android系统的硬件接口。 首先，我们要了解Android是如何控制硬件的。Android系统通过HAL...
Android控制闪光灯的方法(打开与关闭)
09-02
- 从Android 5.0（API级别21）开始，可以使用`Camera2` API来更精确地控制相机，包括闪光灯。`Camera2` API提供了更多的控制选项，但其使用相对复杂，需要更多的学习和理解。 总的来说，Android控制闪光灯主要是...
白光LED闪光灯直接电流控制方案
01-19
如图1所示的电路，这种结构的电路会利用复杂的反馈分压电路提供稳流和电压...　图1 具有电压过载保护的LED闪光灯电路 　这样，只要白光LED与检流电阻压降之和低于电阻分压器的编程电压，即可实现白光LED的电流调节。如
Android闪光灯的简单控制源码.zip
07-03
在Android平台上，开发人员可以利用系统提供的API来实现对设备闪光灯的控制。这个"Android闪光灯的简单控制源码.zip"文件很可能包含了实现这一功能的示例代码。以下是对这个主题的详细解释： 首先，Android系统为...
android led闪烁功能,详解Android应用层制作LED指示灯
weixin_29877113的博客
05-26 589
详解Android应用层制作LED指示灯在Java应用层修改LED指示灯的颜色，这个花了我半天时间， 才实现该功能!public class LEDActivity extends Activity implements View.OnClickListener {private static final String TAG = "LED";Button mLedTest;int mLedSta...
Android闪光灯实现
07-04
Android闪光灯实现 https://blog.csdn.net/qq_31939617/article/details/80750933
Android通过jni控制LED灯
12-19
一个简单的demo。安卓通过jni直接驱动/dev下的led灯设备。不区分硬件，只要在/dev下能看到驱动的设备文件就可以用这种方式
android 打开闪光灯
hengqiaqia的专栏
12-12 2260
在android中打开闪光灯的方法有两种，一种是获取硬件服务，通过反射的方式来操作闪光灯。另外一种是获得Camera对象，通过设置Camera的参数来操作闪光灯。一下是一个操作闪光灯的工具类：实现了两种方式操作闪光灯。通过switchFlashlight方法是通过反射的方式操作，通过turnLightOn，turnLightOff方法操作是通过设置Camera来操作闪关灯的。通过反射的方法貌似在4...
第四章：Android灯光系统(2)-led_class驱动
江南才尽江南山，年少无知年少狂！
02-09 1999
在我们的安卓手机中，有多种灯光，在SDK/hardware/libhardware/include/hardware文件中，可以看到如下定义 #define LIGHT_ID_BACKLIGHT &quot;backlight&quot; #define LIGHT_ID_KEYBOARD &quot;keyboard&quot; #define LIGHT_ID_BUTTONS ......
android驱动例子(led灯控制),android驱动例子（LED灯控制）
weixin_28778005的博客
05-28 968
--作者：赖玉平(Peter Lai)aulyp@163.com本例子，讲述在android2.1上完全自已开发一个驱动去控制硬件口并写应用测试该驱动，通过这样一个例子，解析android下的驱动开发流程的应用调用流程，可以说是很好的入门引导要达到的效果：通过android的应用，调用驱动程序，在开发板上控制4个LED的亮灭。一、硬件原理 如上图，通过4个IO口控制这LED，低电平LED亮，这4个...
Android 下led 的控制(上)--Android部分
dingfengen的专栏
06-08 7113
首先说一下我的开发环境，硬件环境开发板使用的是全志的CQA83T板子，Android开发是windows下的eclipse。关于Android下控制led，主要有两大部分，一是Android程序，二是Linux驱动开发。Android部分的开发肯定要使用Android ndk，jni编程，通过jni来调用Linux下的C函数从而控制led设备。关于ndk的安装，和简单使用我在另外的博客里面已经写了
Android 适配---notification led 呼吸灯
简
07-26 1万+
题外话： 2010年10月乔帮主在投资人和华尔街fenxishi
android闪光灯参数,Android-关于android调用闪光灯的问题
weixin_36255718的博客
05-26 252
package com.wjh.myset;import java.io.PrintStream;import java.lang.reflect.Method;import android.os.IBinder;public class MyFlashLight {private Object svc = null;private Method getFlashlightEnabled = nu...
Android手电筒应用开发教程：使用Camera控制闪光灯
"这篇教程详细介绍了如何在Android平台上开发一个简单实用的手电筒应用，主要涉及了使用Camera类控制闪光灯以及自定义UI按钮的操作。" 在Android开发中，创建一个手电筒应用是一个常见的练习，它能帮助开发者熟悉...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值