Hi,
I believe the title says it all. I tried to find the solution here but without success. While Im satisfied with my Nexus 7 case, I found out that sometimes if I just close it and put the tablet into bag it fails to turn the screen off. So, Id prefer to do that manually.
Is there a software way to disable the magnetic sensor? I dont want to play tailor with my case ...
Just manually turn it off. Closing the case won't turn your screen back on...
If the problem is that as the tab shuffles around in your bag and the case cover opens just enough to turn it back on, that's a different issue. Then you'll need some type of band or something to put around it.
Sent from my Nexus 7 using Tapatalk 2
Thanks, that will do. :good: But is there really NO sw way to disable it? I dont like automatic functions just lying around ...
michalurban said:
Thanks, that will do. :good: But is there really NO sw way to disable it? I dont like automatic functions just lying around ...
Click to expand...
Click to collapse
Unless you find a way in the code to disable it or figure out how to physically remove it.
or... just get a case with out a magnet in it.
knitler said:
Unless you find a way in the code to disable it or figure out how to physically remove it.
or... just get a case with out a magnet in it.
Click to expand...
Click to collapse
Ive been hoping in someone else finding the way to disable it in the code. Anyway, I guess Ill get another case and see ... THX! :good:
michalurban said:
Ive been hoping in someone else finding the way to disable it in the code. Anyway, I guess Ill get another case and see ... THX! :good:
Click to expand...
Click to collapse
Until seeing it on youtube, I wasn't even aware of this feature. The amazing thing to me is the fact that the actual case sold for the N7 at the google store does not have this feature (ie. no magnet)......
Im afraid I took the matters into my own hands and solved my magnetic problem once and for all ... :laugh:
michalurban said:
Im afraid I took the matters into my own hands and solved my magnetic problem once and for all ... :laugh:
Click to expand...
Click to collapse
Your case isn't nearly as attractive now.
Seriously, I can't see how this was a real issue unless your case was designed badly. Example; some flip-around cases if not shielded will turn the N7 off when flipped around.
khaytsus said:
Your case isn't nearly as attractive now.
Seriously, I can't see how this was a real issue unless your case was designed badly. Example; some flip-around cases if not shielded will turn the N7 off when flipped around.
Click to expand...
Click to collapse
Well, small hole inside the case isnt a big deal for me. Anyway, the problem was that the case managed to turn the tablet off only when closed really good. And if closed, only a few milimeters (say 2) of movement of the front cover to the left made the case wake my N7. I couldnt really be sure what would the Thing do in my bag - but the case itself is good, co I kept it this way.
This can be done strictly via software. Here is a modified version of the kernel driver from drivers/input/lid.c that allows you to enable/disable this feature. By default, it acts normally. To disable the magnetic switch, do "echo 0 > /sys/module/lid/parameters/lid_enabled", or use any other app you want to write to that file. To enable it again, just write a non-zero value to the parameter. Ive only tested it on my nexus7, but it seems to work perfectly.
Code:
/*
* ASUS Lid driver.
*/
#include <linux/module.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
#include <linux/gpio_event.h>
#include <asm/gpio.h>
#include <../gpio-names.h>
#include "lid.h"
MODULE_DESCRIPTION(DRIVER_LID);
MODULE_LICENSE("GPL");
/*
* functions declaration
*/
static void lid_report_function(struct work_struct *dat);
static int lid_input_device_create(void);
static ssize_t show_lid_status(struct device *class, struct device_attribute *attr,char *buf);
/*
* global variable
*/
static unsigned int hall_sensor_gpio = TEGRA_GPIO_PS6;
static struct workqueue_struct *lid_wq;
static struct input_dev *lid_indev;
static struct platform_device *lid_dev; /* Device structure */
// to allow enabling/disabling the lid switch
static int lid_enabled = 1;
module_param( lid_enabled, int, 0644 );
static DEVICE_ATTR(lid_status, S_IWUSR | S_IRUGO, show_lid_status,NULL);
/* Attribute Descriptor */
static struct attribute *lid_attrs[] = {
&dev_attr_lid_status.attr,
NULL
};
/* Attribute group */
static struct attribute_group lid_attr_group = {
.attrs = lid_attrs,
};
static ssize_t show_lid_status(struct device *class,struct device_attribute *attr,char *buf)
{
return sprintf(buf, "%d\n", gpio_get_value(hall_sensor_gpio));
}
static irqreturn_t lid_interrupt_handler(int irq, void *dev_id){
if( lid_enabled )
{
int gpio = irq_to_gpio(irq);
if (gpio == hall_sensor_gpio){
LID_NOTICE("LID interrupt handler...gpio: %d..\n", gpio_get_value(hall_sensor_gpio));
queue_delayed_work(lid_wq, &lid_hall_sensor_work, 0);
}
}
else
{
printk( "lid: ignoring irq\n" );
}
return IRQ_HANDLED;
}
static int lid_irq_hall_sensor(void)
{
int rc = 0 ;
unsigned gpio = hall_sensor_gpio;
unsigned irq = gpio_to_irq(hall_sensor_gpio);
const char* label = "hall_sensor" ;
LID_INFO("gpio = %d, irq = %d\n", gpio, irq);
LID_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
tegra_gpio_enable(gpio);
rc = gpio_request(gpio, label);
if (rc) {
LID_ERR("gpio_request failed for input %d\n", gpio);
}
rc = gpio_direction_input(gpio) ;
if (rc) {
LID_ERR("gpio_direction_input failed for input %d\n", gpio);
goto err_gpio_direction_input_failed;
}
LID_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
rc = request_irq(irq, lid_interrupt_handler,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, label, lid_indev);
if (rc < 0) {
LID_ERR("Could not register for %s interrupt, irq = %d, rc = %d\n", label, irq, rc);
rc = -EIO;
goto err_gpio_request_irq_fail ;
}
enable_irq_wake(irq);
LID_INFO("LID irq = %d, rc = %d\n", irq, rc);
return 0 ;
err_gpio_request_irq_fail :
gpio_free(gpio);
err_gpio_direction_input_failed:
return rc;
}
static void lid_report_function(struct work_struct *dat)
{
int value = 0;
if (lid_indev == NULL){
LID_ERR("LID input device doesn't exist\n");
return;
}
msleep(CONVERSION_TIME_MS);
value = gpio_get_value(hall_sensor_gpio);
if(value)
input_report_switch(lid_indev, SW_LID, 0);
else
input_report_switch(lid_indev, SW_LID, 1);
input_sync(lid_indev);
LID_NOTICE("SW_LID report value = %d\n", value);
}
static int lid_input_device_create(void){
int err = 0;
lid_indev = input_allocate_device();
if (!lid_indev) {
LID_ERR("lid_indev allocation fails\n");
err = -ENOMEM;
goto exit;
}
lid_indev->name = "lid_input";
lid_indev->phys = "/dev/input/lid_indev";
set_bit(EV_SW, lid_indev->evbit);
set_bit(SW_LID, lid_indev->swbit);
err = input_register_device(lid_indev);
if (err) {
LID_ERR("lid_indev registration fails\n");
goto exit_input_free;
}
return 0;
exit_input_free:
input_free_device(lid_indev);
lid_indev = NULL;
exit:
return err;
}
static int __init lid_init(void)
{
int err_code = 0;
printk(KERN_INFO "%s+ #####\n", __func__);
LID_NOTICE("start LID init.....\n");
lid_dev = platform_device_register_simple("LID", -1, NULL, 0);
if (!lid_dev){
printk ("LID_init: error\n");
return -ENOMEM;
}
sysfs_create_group((struct kobject*)&lid_dev->dev.kobj, &lid_attr_group);
err_code = lid_input_device_create();
if(err_code != 0)
return err_code;
lid_wq = create_singlethread_workqueue("lid_wq");
INIT_DELAYED_WORK_DEFERRABLE(&lid_hall_sensor_work, lid_report_function);
lid_irq_hall_sensor();
return 0;
}
static void __exit lid_exit(void)
{
input_unregister_device(lid_indev);
sysfs_remove_group(&lid_dev->dev.kobj, &lid_attr_group);
platform_device_unregister(lid_dev);
}
module_init(lid_init);
module_exit(lid_exit);
So how would one go about implementing this modified code? Personally, I can't believe that there is not a standard setting to enable/disable this feature, but it ROM developers and/or users can implement this modified code easily, that would be a big help!
Thanks.
Sent from my ASUS Transformer Pad TF700T using Tapatalk 2
jtrosky said:
So how would one go about implementing this modified code? Personally, I can't believe that there is not a standard setting to enable/disable this feature, but it ROM developers and/or users can implement this modified code easily, that would be a big help!
Thanks.
Click to expand...
Click to collapse
To disable the magnetic switch, do "echo 0 > /sys/module/lid/parameters/lid_enabled"
Click to expand...
Click to collapse
The code was for reference. EDIT: No it's not, I'm an idiot.
Not the way I read it. The modified code has to be built into a kernel to access the option file.
Sent from my Nexus 7 using xda app-developers app
Yes, this is one of the files that make up the kernel, with about 10 lines added to it. You would have to replace the file in the kernel source code, build the kernel, insert that kernel into a boot.img, and flash it to your tablet. If you can't manage all that, then you could pester the person who does make the kernel you're using to add it.
rmm200 said:
Not the way I read it. The modified code has to be built into a kernel to access the option file.
Click to expand...
Click to collapse
This is what I get for reading things too fast.. Ah well.
gianptune said:
This can be done strictly via software. Here is a modified version of the kernel driver from drivers/input/lid.c that allows you to enable/disable this feature. By default, it acts normally. To disable the magnetic switch, do "echo 0 > /sys/module/lid/parameters/lid_enabled", or use any other app you want to write to that file. To enable it again, just write a non-zero value to the parameter. Ive only tested it on my nexus7, but it seems to work perfectly.
Code:
/*
* ASUS Lid driver.
*/
#include <linux/module.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
#include <linux/gpio_event.h>
#include <asm/gpio.h>
#include <../gpio-names.h>
#include "lid.h"
MODULE_DESCRIPTION(DRIVER_LID);
MODULE_LICENSE("GPL");
/*
* functions declaration
*/
static void lid_report_function(struct work_struct *dat);
static int lid_input_device_create(void);
static ssize_t show_lid_status(struct device *class, struct device_attribute *attr,char *buf);
/*
* global variable
*/
static unsigned int hall_sensor_gpio = TEGRA_GPIO_PS6;
static struct workqueue_struct *lid_wq;
static struct input_dev *lid_indev;
static struct platform_device *lid_dev; /* Device structure */
// to allow enabling/disabling the lid switch
static int lid_enabled = 1;
module_param( lid_enabled, int, 0644 );
static DEVICE_ATTR(lid_status, S_IWUSR | S_IRUGO, show_lid_status,NULL);
/* Attribute Descriptor */
static struct attribute *lid_attrs[] = {
&dev_attr_lid_status.attr,
NULL
};
/* Attribute group */
static struct attribute_group lid_attr_group = {
.attrs = lid_attrs,
};
static ssize_t show_lid_status(struct device *class,struct device_attribute *attr,char *buf)
{
return sprintf(buf, "%d\n", gpio_get_value(hall_sensor_gpio));
}
static irqreturn_t lid_interrupt_handler(int irq, void *dev_id){
if( lid_enabled )
{
int gpio = irq_to_gpio(irq);
if (gpio == hall_sensor_gpio){
LID_NOTICE("LID interrupt handler...gpio: %d..\n", gpio_get_value(hall_sensor_gpio));
queue_delayed_work(lid_wq, &lid_hall_sensor_work, 0);
}
}
else
{
printk( "lid: ignoring irq\n" );
}
return IRQ_HANDLED;
}
static int lid_irq_hall_sensor(void)
{
int rc = 0 ;
unsigned gpio = hall_sensor_gpio;
unsigned irq = gpio_to_irq(hall_sensor_gpio);
const char* label = "hall_sensor" ;
LID_INFO("gpio = %d, irq = %d\n", gpio, irq);
LID_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
tegra_gpio_enable(gpio);
rc = gpio_request(gpio, label);
if (rc) {
LID_ERR("gpio_request failed for input %d\n", gpio);
}
rc = gpio_direction_input(gpio) ;
if (rc) {
LID_ERR("gpio_direction_input failed for input %d\n", gpio);
goto err_gpio_direction_input_failed;
}
LID_INFO("GPIO = %d , state = %d\n", gpio, gpio_get_value(gpio));
rc = request_irq(irq, lid_interrupt_handler,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, label, lid_indev);
if (rc < 0) {
LID_ERR("Could not register for %s interrupt, irq = %d, rc = %d\n", label, irq, rc);
rc = -EIO;
goto err_gpio_request_irq_fail ;
}
enable_irq_wake(irq);
LID_INFO("LID irq = %d, rc = %d\n", irq, rc);
return 0 ;
err_gpio_request_irq_fail :
gpio_free(gpio);
err_gpio_direction_input_failed:
return rc;
}
static void lid_report_function(struct work_struct *dat)
{
int value = 0;
if (lid_indev == NULL){
LID_ERR("LID input device doesn't exist\n");
return;
}
msleep(CONVERSION_TIME_MS);
value = gpio_get_value(hall_sensor_gpio);
if(value)
input_report_switch(lid_indev, SW_LID, 0);
else
input_report_switch(lid_indev, SW_LID, 1);
input_sync(lid_indev);
LID_NOTICE("SW_LID report value = %d\n", value);
}
static int lid_input_device_create(void){
int err = 0;
lid_indev = input_allocate_device();
if (!lid_indev) {
LID_ERR("lid_indev allocation fails\n");
err = -ENOMEM;
goto exit;
}
lid_indev->name = "lid_input";
lid_indev->phys = "/dev/input/lid_indev";
set_bit(EV_SW, lid_indev->evbit);
set_bit(SW_LID, lid_indev->swbit);
err = input_register_device(lid_indev);
if (err) {
LID_ERR("lid_indev registration fails\n");
goto exit_input_free;
}
return 0;
exit_input_free:
input_free_device(lid_indev);
lid_indev = NULL;
exit:
return err;
}
static int __init lid_init(void)
{
int err_code = 0;
printk(KERN_INFO "%s+ #####\n", __func__);
LID_NOTICE("start LID init.....\n");
lid_dev = platform_device_register_simple("LID", -1, NULL, 0);
if (!lid_dev){
printk ("LID_init: error\n");
return -ENOMEM;
}
sysfs_create_group((struct kobject*)&lid_dev->dev.kobj, &lid_attr_group);
err_code = lid_input_device_create();
if(err_code != 0)
return err_code;
lid_wq = create_singlethread_workqueue("lid_wq");
INIT_DELAYED_WORK_DEFERRABLE(&lid_hall_sensor_work, lid_report_function);
lid_irq_hall_sensor();
return 0;
}
static void __exit lid_exit(void)
{
input_unregister_device(lid_indev);
sysfs_remove_group(&lid_dev->dev.kobj, &lid_attr_group);
platform_device_unregister(lid_dev);
}
module_init(lid_init);
module_exit(lid_exit);
Click to expand...
Click to collapse
im interested in trying this on the sprint GS4.
can you possibly be a little more detailed on what i need to do?
thank you very much.
In my opinion the best solution to this problem is two steps:
1) Remove any magnet in the case cover. Disables smart cover feature physically rather than software.
2) Use NFC tags with programs configured to control exactly the items needed, e.g. sleep mode, settings, wi-fi, etc.
This may require two to four NFC tags, one for each major scenario. These might be "deep sleep, battery save", "sleep with fast restore", "wake no communicate", "wake and communication", etc. You could put the tags on a strip of material along with color codes. Touch the tag to the NFC sensor and no messing around.
As others may notice, I attended the XDA dev conference. LOL
As I know all magnetic cases or stuffs are harmful for mobile phones or tablets...
By the way do you guys think that, can this little magnet in the case ، hurm n7 in the long term ?
Xposed Module
Somebody made a Xposed module for the Moto G that disables the magnetic lock.
It could work on the N7, but i dont have a smart cover to try.
http://forum.xda-developers.com/showthread.php?t=2621807
sasa31 said:
As I know all magnetic cases or stuffs are harmful for mobile phones or tablets...
By the way do you guys think that, can this little magnet in the case ، hurm n7 in the long term ?
Click to expand...
Click to collapse
I ordered my N7 during the IO in which it was announced. Been in a magnetic case since then, so about a year and a half. What do you "know" is harmful? A static magnetic field is unlikely to harm solid state electronics or affect their operation.
Sent from my SCH-I545 using Tapatalk
So I am building a program with a notification that activates 3 hours after the activity is stopped (for testing purposes I am currently using minutes). This is what my main activity looks like...
Code:
Override
public void onStop() {
super.onStop();
Calendar calendar = Calendar.getInstance();
int alarmTime = (calendar.get(Calendar.MINUTE)) + 3;
calendar.set(Calendar.MINUTE,alarmTime);
Intent intent3 = new Intent(getApplicationContext(),timeReceiver.class);
PendingIntent pendingIntent3 = PendingIntent.getBroadcast(getApplicationContext(),100,intent3,PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
alarmManager.setRepeating(AlarmManager.RTC_WAKEUP,calendar.getTimeInMillis(),AlarmManager.INTERVAL_DAY,pendingIntent3);
}
@Override
protected void onRestart() {
super.onRestart();
//this.onCreate(null);
}
This is what my broadcast receiver class looks like...
Code:
public class timeReceiver extends BroadcastReceiver{
@Override
public void onReceive(Context context, Intent intent) {
NotificationManager notificationManager =(NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
Intent repeating_intent = new Intent(context, RepeatingActivity.class);
repeating_intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(context,100,repeating_intent,PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
builder.setContentIntent(pendingIntent);
builder.setSmallIcon(android.R.drawable.arrow_up_float);
builder.setContentTitle("Timer Notification");
builder.setContentText("blaaah blaaah blah");
builder.setAutoCancel(true);
notificationManager.notify(100,builder.build());
}
}
3 minutes after running the stop code the timer is activated the way it's supposed to, however my problem is that if the code is executed a second time within this 3 minute period - then no notification is pushed at all. My hope is that the alarm would reset and trigger 3 minutes after the last execution of the onStop() method, but it doesn't. I don't really understand why it doesn't, if anyone could give me insight/ a possible solution I would be grateful. Also the SDK version is 24.
I've already worked on a alarm scheduler (notification) just yesterday.
So here comes my working code (you can find it in github / binogure-studio):
Code:
public void schedule_local_notification(String title, String content, int delay, int notification_id) {
// delay is after how much time(in millis) from current time you want to schedule the notification
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, activity.getPackageName() + CHANNEL_ID)
.setContentTitle(title)
.setContentText(content)
.setAutoCancel(true)
.setSmallIcon(R.drawable.ic_stat_name)
.setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.mipmap.ic_launcher))
.setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION));
Intent intent = new Intent(context, Godot.class);
PendingIntent intentActivity = PendingIntent.getActivity(context, notification_id, intent, PendingIntent.FLAG_CANCEL_CURRENT);
builder.setContentIntent(intentActivity);
Notification notification = builder.build();
Intent notificationIntent = new Intent(context, LocalNotificationReceiver.class);
notificationIntent.putExtra(LocalNotificationReceiver.NOTIFICATION_ID, notification_id);
notificationIntent.putExtra(LocalNotificationReceiver.NOTIFICATION, notification);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notification_id, notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT);
long futureInMillis = SystemClock.elapsedRealtime() + delay * 1000;
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, futureInMillis, pendingIntent);
}
public void cancel_local_notification(int notification_id) {
try {
Intent intent = new Intent(context, LocalNotificationReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, notification_id, intent, PendingIntent.FLAG_UPDATE_CURRENT);
AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.cancel(pendingIntent);
} catch (Exception ex) {
Log.w(TAG, "Cannot show local notification: " + ex.getMessage());
}
}