src/org/sflphone/utils/CallProximityManager.java - jami-client-android - Gitiles

 /*
  *  Copyright (C) 2010-2012 Regis Montoya (aka r3gis - www.r3gis.fr)
  *  Copyright (C) 2004-2013 Savoir-Faire Linux Inc.
  *
  *  Author: Alexandre Lision <alexandre.lision@savoirfairelinux.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 3 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  *  Additional permission under GNU GPL version 3 section 7:
  *
  *  If you modify this program, or any covered work, by linking or
  *  combining it with the OpenSSL project's OpenSSL library (or a
  *  modified version of that library), containing parts covered by the
  *  terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
  *  grants you additional permission to convey the resulting work.
  *  Corresponding Source for a non-source form of such a combination
  *  shall include the source code for the parts of OpenSSL used as well
  *  as that of the covered work.
  */
 package org.sflphone.utils;

 import java.lang.reflect.Field;
 import java.lang.reflect.Method;

 import org.sflphone.utils.AccelerometerListener.OrientationListener;

 import android.content.Context;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.net.wifi.WifiManager;
 import android.os.PowerManager;
 import android.os.PowerManager.WakeLock;
 import android.util.Log;

 /**
  * Class to manage proximity detection while in call.
  *
  */
 public class CallProximityManager implements SensorEventListener, OrientationListener {
     private static final String THIS_FILE = "CallProximityManager";

     private Context mContext;

     private SensorManager sensorManager;
     private PowerManager powerManager;

     // Timeout management of screen locker ui
     // private ScreenLocker mScreenLocker;
     private Boolean useTimeoutOverlay = null;

     // Self management of proximity sensor
     private Sensor proximitySensor;
     private static final float PROXIMITY_THRESHOLD = 5.0f;
     private boolean invertProximitySensor = false;
     private boolean proximitySensorTracked = false;
     private boolean isFirstRun = true;
     private ProximityDirector mDirector = null;

     // The hidden api that uses a wake lock
     private WakeLock proximityWakeLock;

     // The accelerometer
     private AccelerometerListener accelerometerManager;
     private int mOrientation;
     private boolean accelerometerEnabled = false;

     private int WAIT_FOR_PROXIMITY_NEGATIVE = 1;
     // private final static int SCREEN_LOCKER_ACQUIRE_DELAY = "google_sdk".equals(Build.PRODUCT) ? ScreenLocker.WAIT_BEFORE_LOCK_LONG
     // : ScreenLocker.WAIT_BEFORE_LOCK_SHORT;

     private static Method powerLockReleaseIntMethod;

     public interface ProximityDirector {
         public boolean shouldActivateProximity();

         public void onProximityTrackingChanged(boolean acquired);
     }

     public CallProximityManager(Context context, ProximityDirector director) {
         mContext = context;
         mDirector = director;
         // mScreenLocker = screenLocker;

         sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
         powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
         accelerometerManager = new AccelerometerListener(context, this);

         // Try to detect the hidden api
         if (powerManager != null) {
             WifiManager wman = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

             // Try to use powermanager proximity sensor
             try {
                 boolean supportProximity = false;
                 Field f = PowerManager.class.getDeclaredField("PROXIMITY_SCREEN_OFF_WAKE_LOCK");
                 int proximityScreenOffWakeLock = (Integer) f.get(null);
                 if (Compatibility.isCompatible(17)) {
                     // Changes of the private API on android 4.2
                     Method method = powerManager.getClass().getDeclaredMethod("isWakeLockLevelSupported", int.class);
                     supportProximity = (Boolean) method.invoke(powerManager, proximityScreenOffWakeLock);
                     Log.d(THIS_FILE, "Use 4.2 detection way for proximity sensor detection. Result is " + supportProximity);
                 } else {
                     Method method = powerManager.getClass().getDeclaredMethod("getSupportedWakeLockFlags");
                     int supportedFlags = (Integer) method.invoke(powerManager);
                     Log.d(THIS_FILE, "Proxmity flags supported : " + supportedFlags);
                     supportProximity = ((supportedFlags & proximityScreenOffWakeLock) != 0x0);
                 }
                 if (supportProximity) {
                     Log.d(THIS_FILE, "We can use native screen locker !!");
                     proximityWakeLock = powerManager.newWakeLock(proximityScreenOffWakeLock, "com.csipsimple.CallProximity");
                     proximityWakeLock.setReferenceCounted(false);
                 }

             } catch (Exception e) {
                 Log.d(THIS_FILE, "Impossible to get power manager supported wake lock flags ");
             }
             if (powerLockReleaseIntMethod == null) {
                 try {
                     powerLockReleaseIntMethod = proximityWakeLock.getClass().getDeclaredMethod("release", int.class);

                 } catch (Exception e) {
                     Log.d(THIS_FILE, "Impossible to get power manager release with it");
                 }

             }
         }

         // Try to detect a proximity sensor as fallback
         if (proximityWakeLock == null) {
             proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
             // invertProximitySensor = SipConfigManager.getPreferenceBooleanValue(context, SipConfigManager.INVERT_PROXIMITY_SENSOR);
         }

     }

     public synchronized void startTracking() {
         // If we should manage it ourselves
         if (proximitySensor != null && !proximitySensorTracked) {
             // Fall back to manual mode
             isFirstRun = true;
             Log.d(THIS_FILE, "Register sensor");
             sensorManager.registerListener(this, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
             proximitySensorTracked = true;
         }
         if (!accelerometerEnabled) {
             accelerometerManager.enable(true);
             accelerometerEnabled = true;
         }
     }

     public synchronized void stopTracking() {
         if (proximitySensor != null && proximitySensorTracked) {
             proximitySensorTracked = false;
             sensorManager.unregisterListener(this);
             Log.d(THIS_FILE, "Unregister to sensor is done !!!");
         }
         if (accelerometerEnabled) {
             accelerometerManager.enable(false);
             accelerometerEnabled = false;
         }
         // mScreenLocker.tearDown();
     }

     @Override
     public void onAccuracyChanged(Sensor sensor, int accuracy) {
     }

     @Override
     public void onSensorChanged(SensorEvent event) {
         // Log.d(THIS_FILE, "Tracked : "+proximitySensorTracked);
         if (proximitySensorTracked && !isFirstRun) {
             float distance = event.values[0];
             boolean active = (distance >= 0.0 && distance < PROXIMITY_THRESHOLD && distance < event.sensor.getMaximumRange());
             if (invertProximitySensor) {
                 active = !active;
             }
             Log.d(THIS_FILE, "Distance is now " + distance);

             boolean isValidCallState = false;
             if (mDirector != null) {
                 isValidCallState = mDirector.shouldActivateProximity();
             }

             if (isValidCallState && active) {
                 // mScreenLocker.show();
                 if (mDirector != null) {
                     mDirector.onProximityTrackingChanged(true);
                 }
             } else {
                 // mScreenLocker.hide();
                 if (mDirector != null) {
                     mDirector.onProximityTrackingChanged(false);
                 }
             }

         }
         if (isFirstRun) {
             isFirstRun = false;
         }
     }

     private boolean isProximityWakeHeld = false;

     /**
      * Release any lock taken by the proximity sensor
      */
     public synchronized void release(int flag) {
         if (proximityWakeLock != null && isProximityWakeHeld) {
             boolean usedNewRelease = false;
             if (powerLockReleaseIntMethod != null) {
                 try {
                     powerLockReleaseIntMethod.invoke(proximityWakeLock, flag);
                     usedNewRelease = true;
                     // Log.d(THIS_FILE, "CALL NEW RELEASE WITH FLAG " + flag);
                 } catch (Exception e) {
                     Log.d(THIS_FILE, "Error calling new release method ", e);
                 }
             }
             if (!usedNewRelease) {
                 proximityWakeLock.release();
             }
             isProximityWakeHeld = false;
         }

         if (shouldUseTimeoutOverlay()) {
             // mScreenLocker.hide();
         }
         // Notify
         if (mDirector != null) {
             mDirector.onProximityTrackingChanged(false);
         }
     }

     public synchronized void acquire() {
         if (proximityWakeLock != null && !isProximityWakeHeld) {
             proximityWakeLock.acquire();
             isProximityWakeHeld = true;
         }
         if (shouldUseTimeoutOverlay()) {
             // mScreenLocker.delayedLock(SCREEN_LOCKER_ACQUIRE_DELAY);
         }
         // Notify
         if (mDirector != null) {
             mDirector.onProximityTrackingChanged(true);
         }
     }

     /**
      * Update proximity lock mode depending on current state
      */
     public synchronized void updateProximitySensorMode() {

         // We do not keep the screen off when the user is outside in-call screen and we are
         // horizontal, but we do not force it on when we become horizontal until the
         // proximity sensor goes negative.
         boolean horizontal = (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);

         boolean activeRegardingCalls = false;
         if (mDirector != null) {
             activeRegardingCalls = mDirector.shouldActivateProximity();
         }

         Log.d(THIS_FILE, "Horizontal : " + horizontal + " and activate for calls " + activeRegardingCalls);
         if (activeRegardingCalls && !horizontal) {
             // Phone is in use! Arrange for the screen to turn off
             // automatically when the sensor detects a close object.
             acquire();
         } else {
             // Phone is either idle, or ringing. We don't want any
             // special proximity sensor behavior in either case.
             int flags = (!horizontal ? 0 : WAIT_FOR_PROXIMITY_NEGATIVE);
             release(flags);
         }
     }

     /**
      * Should the application display the overlay after a timeout.
      *
      * @return false if we are in table mode or if proximity sensor can be used
      */
     private boolean shouldUseTimeoutOverlay() {
         if (useTimeoutOverlay == null) {
             useTimeoutOverlay = proximitySensor == null && proximityWakeLock == null && !Compatibility.isTabletScreen(mContext);
         }
         return useTimeoutOverlay;
     }

     public void restartTimer() {
         if (shouldUseTimeoutOverlay()) {
             // mScreenLocker.delayedLock(ScreenLocker.WAIT_BEFORE_LOCK_LONG);
         }
     }

     @Override
     public void orientationChanged(int orientation) {
         mOrientation = orientation;
         updateProximitySensorMode();
     }

 }
	/*
	* Copyright (C) 2010-2012 Regis Montoya (aka r3gis - www.r3gis.fr)
	* Copyright (C) 2004-2013 Savoir-Faire Linux Inc.
	*
	* Author: Alexandre Lision <alexandre.lision@savoirfairelinux.com>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 3 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*
	* Additional permission under GNU GPL version 3 section 7:
	*
	* If you modify this program, or any covered work, by linking or
	* combining it with the OpenSSL project's OpenSSL library (or a
	* modified version of that library), containing parts covered by the
	* terms of the OpenSSL or SSLeay licenses, Savoir-Faire Linux Inc.
	* grants you additional permission to convey the resulting work.
	* Corresponding Source for a non-source form of such a combination
	* shall include the source code for the parts of OpenSSL used as well
	* as that of the covered work.
	*/
	package org.sflphone.utils;

	import java.lang.reflect.Field;
	import java.lang.reflect.Method;

	import org.sflphone.utils.AccelerometerListener.OrientationListener;

	import android.content.Context;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.net.wifi.WifiManager;
	import android.os.PowerManager;
	import android.os.PowerManager.WakeLock;
	import android.util.Log;

	/**
	* Class to manage proximity detection while in call.
	*
	*/
	public class CallProximityManager implements SensorEventListener, OrientationListener {
	private static final String THIS_FILE = "CallProximityManager";

	private Context mContext;

	private SensorManager sensorManager;
	private PowerManager powerManager;

	// Timeout management of screen locker ui
	// private ScreenLocker mScreenLocker;
	private Boolean useTimeoutOverlay = null;

	// Self management of proximity sensor
	private Sensor proximitySensor;
	private static final float PROXIMITY_THRESHOLD = 5.0f;
	private boolean invertProximitySensor = false;
	private boolean proximitySensorTracked = false;
	private boolean isFirstRun = true;
	private ProximityDirector mDirector = null;

	// The hidden api that uses a wake lock
	private WakeLock proximityWakeLock;

	// The accelerometer
	private AccelerometerListener accelerometerManager;
	private int mOrientation;
	private boolean accelerometerEnabled = false;

	private int WAIT_FOR_PROXIMITY_NEGATIVE = 1;
	// private final static int SCREEN_LOCKER_ACQUIRE_DELAY = "google_sdk".equals(Build.PRODUCT) ? ScreenLocker.WAIT_BEFORE_LOCK_LONG
	// : ScreenLocker.WAIT_BEFORE_LOCK_SHORT;

	private static Method powerLockReleaseIntMethod;

	public interface ProximityDirector {
	public boolean shouldActivateProximity();

	public void onProximityTrackingChanged(boolean acquired);
	}

	public CallProximityManager(Context context, ProximityDirector director) {
	mContext = context;
	mDirector = director;
	// mScreenLocker = screenLocker;

	sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
	powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
	accelerometerManager = new AccelerometerListener(context, this);

	// Try to detect the hidden api
	if (powerManager != null) {
	WifiManager wman = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

	// Try to use powermanager proximity sensor
	try {
	boolean supportProximity = false;
	Field f = PowerManager.class.getDeclaredField("PROXIMITY_SCREEN_OFF_WAKE_LOCK");
	int proximityScreenOffWakeLock = (Integer) f.get(null);
	if (Compatibility.isCompatible(17)) {
	// Changes of the private API on android 4.2
	Method method = powerManager.getClass().getDeclaredMethod("isWakeLockLevelSupported", int.class);
	supportProximity = (Boolean) method.invoke(powerManager, proximityScreenOffWakeLock);
	Log.d(THIS_FILE, "Use 4.2 detection way for proximity sensor detection. Result is " + supportProximity);
	} else {
	Method method = powerManager.getClass().getDeclaredMethod("getSupportedWakeLockFlags");
	int supportedFlags = (Integer) method.invoke(powerManager);
	Log.d(THIS_FILE, "Proxmity flags supported : " + supportedFlags);
	supportProximity = ((supportedFlags & proximityScreenOffWakeLock) != 0x0);
	}
	if (supportProximity) {
	Log.d(THIS_FILE, "We can use native screen locker !!");
	proximityWakeLock = powerManager.newWakeLock(proximityScreenOffWakeLock, "com.csipsimple.CallProximity");
	proximityWakeLock.setReferenceCounted(false);
	}

	} catch (Exception e) {
	Log.d(THIS_FILE, "Impossible to get power manager supported wake lock flags ");
	}
	if (powerLockReleaseIntMethod == null) {
	try {
	powerLockReleaseIntMethod = proximityWakeLock.getClass().getDeclaredMethod("release", int.class);

	} catch (Exception e) {
	Log.d(THIS_FILE, "Impossible to get power manager release with it");
	}

	}
	}

	// Try to detect a proximity sensor as fallback
	if (proximityWakeLock == null) {
	proximitySensor = sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
	// invertProximitySensor = SipConfigManager.getPreferenceBooleanValue(context, SipConfigManager.INVERT_PROXIMITY_SENSOR);
	}

	}

	public synchronized void startTracking() {
	// If we should manage it ourselves
	if (proximitySensor != null && !proximitySensorTracked) {
	// Fall back to manual mode
	isFirstRun = true;
	Log.d(THIS_FILE, "Register sensor");
	sensorManager.registerListener(this, proximitySensor, SensorManager.SENSOR_DELAY_NORMAL);
	proximitySensorTracked = true;
	}
	if (!accelerometerEnabled) {
	accelerometerManager.enable(true);
	accelerometerEnabled = true;
	}
	}

	public synchronized void stopTracking() {
	if (proximitySensor != null && proximitySensorTracked) {
	proximitySensorTracked = false;
	sensorManager.unregisterListener(this);
	Log.d(THIS_FILE, "Unregister to sensor is done !!!");
	}
	if (accelerometerEnabled) {
	accelerometerManager.enable(false);
	accelerometerEnabled = false;
	}
	// mScreenLocker.tearDown();
	}

	@Override
	public void onAccuracyChanged(Sensor sensor, int accuracy) {
	}

	@Override
	public void onSensorChanged(SensorEvent event) {
	// Log.d(THIS_FILE, "Tracked : "+proximitySensorTracked);
	if (proximitySensorTracked && !isFirstRun) {
	float distance = event.values[0];
	boolean active = (distance >= 0.0 && distance < PROXIMITY_THRESHOLD && distance < event.sensor.getMaximumRange());
	if (invertProximitySensor) {
	active = !active;
	}
	Log.d(THIS_FILE, "Distance is now " + distance);

	boolean isValidCallState = false;
	if (mDirector != null) {
	isValidCallState = mDirector.shouldActivateProximity();
	}

	if (isValidCallState && active) {
	// mScreenLocker.show();
	if (mDirector != null) {
	mDirector.onProximityTrackingChanged(true);
	}
	} else {
	// mScreenLocker.hide();
	if (mDirector != null) {
	mDirector.onProximityTrackingChanged(false);
	}
	}

	}
	if (isFirstRun) {
	isFirstRun = false;
	}
	}

	private boolean isProximityWakeHeld = false;

	/**
	* Release any lock taken by the proximity sensor
	*/
	public synchronized void release(int flag) {
	if (proximityWakeLock != null && isProximityWakeHeld) {
	boolean usedNewRelease = false;
	if (powerLockReleaseIntMethod != null) {
	try {
	powerLockReleaseIntMethod.invoke(proximityWakeLock, flag);
	usedNewRelease = true;
	// Log.d(THIS_FILE, "CALL NEW RELEASE WITH FLAG " + flag);
	} catch (Exception e) {
	Log.d(THIS_FILE, "Error calling new release method ", e);
	}
	}
	if (!usedNewRelease) {
	proximityWakeLock.release();
	}
	isProximityWakeHeld = false;
	}

	if (shouldUseTimeoutOverlay()) {
	// mScreenLocker.hide();
	}
	// Notify
	if (mDirector != null) {
	mDirector.onProximityTrackingChanged(false);
	}
	}

	public synchronized void acquire() {
	if (proximityWakeLock != null && !isProximityWakeHeld) {
	proximityWakeLock.acquire();
	isProximityWakeHeld = true;
	}
	if (shouldUseTimeoutOverlay()) {
	// mScreenLocker.delayedLock(SCREEN_LOCKER_ACQUIRE_DELAY);
	}
	// Notify
	if (mDirector != null) {
	mDirector.onProximityTrackingChanged(true);
	}
	}

	/**
	* Update proximity lock mode depending on current state
	*/
	public synchronized void updateProximitySensorMode() {

	// We do not keep the screen off when the user is outside in-call screen and we are
	// horizontal, but we do not force it on when we become horizontal until the
	// proximity sensor goes negative.
	boolean horizontal = (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);

	boolean activeRegardingCalls = false;
	if (mDirector != null) {
	activeRegardingCalls = mDirector.shouldActivateProximity();
	}

	Log.d(THIS_FILE, "Horizontal : " + horizontal + " and activate for calls " + activeRegardingCalls);
	if (activeRegardingCalls && !horizontal) {
	// Phone is in use! Arrange for the screen to turn off
	// automatically when the sensor detects a close object.
	acquire();
	} else {
	// Phone is either idle, or ringing. We don't want any
	// special proximity sensor behavior in either case.
	int flags = (!horizontal ? 0 : WAIT_FOR_PROXIMITY_NEGATIVE);
	release(flags);
	}
	}

	/**
	* Should the application display the overlay after a timeout.
	*
	* @return false if we are in table mode or if proximity sensor can be used
	*/
	private boolean shouldUseTimeoutOverlay() {
	if (useTimeoutOverlay == null) {
	useTimeoutOverlay = proximitySensor == null && proximityWakeLock == null && !Compatibility.isTabletScreen(mContext);
	}
	return useTimeoutOverlay;
	}

	public void restartTimer() {
	if (shouldUseTimeoutOverlay()) {
	// mScreenLocker.delayedLock(ScreenLocker.WAIT_BEFORE_LOCK_LONG);
	}
	}

	@Override
	public void orientationChanged(int orientation) {
	mOrientation = orientation;
	updateProximitySensorMode();
	}

	}