web-dev-qa-db-fra.com

Comment désactiver le bouton d'accueil dans Android comme le font les applications d'écran de verrouillage?

Je sais que cette question est posée plusieurs fois mais j'ai trouvé qu'aucune des solutions ne fonctionnait. J'ai essayé le code donné ci-dessous ...

   protected void onPause() {
   super.onPause();
    Intent intent = new Intent(this,LockActivity.class);
    intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT |Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivity(intent);
    }

Ce qu'il fait, c'est qu'il remet l'activité actuelle à l'avant-plan lorsque Android est lancé, mais il faut près de 3-4 secondes pour mettre l'activité à nouveau au premier plan lorsque l'écran d'accueil est lancé.

J'ai utilisé des applications d'écran de verrouillage qui ne démarrent même pas l'écran d'accueil lorsque l'on clique sur le bouton d'accueil. Je veux réaliser quelque chose comme ça.

J'ai également utilisé la méthode onUserLeavesHint, la méthode onKeyDown et la méthode onKeyDispatch, mais aucune d'entre elles n'a fonctionné pour moi.

Et s'il vous plaît ne répondez pas ou ne commentez pas comme il n'est pas possible de désactiver le bouton d'accueil dans Android. Pour de telles réponses ou commentaires, je vous suggère de passer par certaines applications d'écran de verrouillage sur PlayStore. J'ai également trouvé une application de travail sur github le long du code source. Cela fonctionnait sur mon téléphone et l'application utilisait disableKeyguard mais quand je fais la même chose dans mon application, cela ne fonctionne pas (disableKeyguard est obsolète mais j'utilise des avertissements @supress ("obsolète")).

androidhomescreenandroid-homebuttonscreen-lock
17
Ruag

source - https://github.com/shaobin0604/Android-HomeKey-Locker

//Copy this class
public class HomeKeyLocker {
    private OverlayDialog mOverlayDialog;
    public void lock(Activity activity) {
        if (mOverlayDialog == null) {
            mOverlayDialog = new OverlayDialog(activity);
            mOverlayDialog.show();
        }
    }
    public void unlock() {
        if (mOverlayDialog != null) {
            mOverlayDialog.dismiss();
            mOverlayDialog = null;
        }
    }
    private static class OverlayDialog extends AlertDialog {

        public OverlayDialog(Activity activity) {
            super(activity, R.style.OverlayDialog);
            WindowManager.LayoutParams params = getWindow().getAttributes();
            params.type =  WindowManager.LayoutParams.TYPE_SYSTEM_ERROR;
            params.dimAmount = 0.0F; // transparent
            params.width = 0;
            params.height = 0;
            params.gravity = Gravity.BOTTOM;
            getWindow().setAttributes(params);
            getWindow().setFlags( WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED |  WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL, 0xffffff);
            setOwnerActivity(activity);
            setCancelable(false);
        }

        public final boolean dispatchTouchEvent(MotionEvent motionevent) {
            return true;
        }

        protected final void onCreate(Bundle bundle) {
            super.onCreate(bundle);
            FrameLayout framelayout = new FrameLayout(getContext());
            framelayout.setBackgroundColor(0);
            setContentView(framelayout);
        }
    }
}

//Paste this in your activity
mHomeKeyLocker = new HomeKeyLocker();
mHomeKeyLocker.lock(this);
7
NitinM

Le moyen sûr de fournir une fonctionnalité d'écran de verrouillage non root sans faille est de combiner votre idée d'application "locker" avec une application de lancement.

Un simple changement dans le manifeste permettra à votre application de s'enregistrer en tant qu'écran d'accueil/lanceur, ce qui donnera à votre .apk le contrôle total du bouton d'accueil: 

<application
    Android:launchMode="singleTask"
    Android:clearTaskOnLaunch="true"
    Android:stateNotNeeded="true"
    Android:icon="@drawable/ic_launcher"
    Android:label="@string/app_name"
    Android:theme="@style/AppTheme" >
    <activity
        Android:name="ch.arnab.simplelauncher.HomeScreen"
        Android:label="@string/app_name"
        Android:launchMode="singleTask"
        Android:excludeFromRecents="true"
        Android:screenOrientation="nosensor">
        <intent-filter>
            <action Android:name="Android.intent.action.MAIN" />

            <!-- These 2 intent-filters identify a launcher: -->
            <category Android:name="Android.intent.category.HOME" />
            <category Android:name="Android.intent.category.DEFAULT" />
        </intent-filter>
    </activity>
</application>

Tiré de ce tutoriel

Vous aurez alors deux activités, une pour votre écran d'accueil, une pour votre écran de verrouillage.

Vous devrez détecter quand l'écran est éteint/allumé , pour montrer l'activité de votre écran de verrouillage:

public class MainActivity extends Activity {

    //Create a receiver for screen-on/screen-off
    BroadcastReceiver mybroadcast = new BroadcastReceiver() {   
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
                //Show lock-screen
            }
            else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
                //Also show lock-screen, to remove flicker/delay when screen on?
            }

        }
    };
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        registerReceiver(mybroadcast, new IntentFilter(Intent.ACTION_SCREEN_ON));
        registerReceiver(mybroadcast, new IntentFilter(Intent.ACTION_SCREEN_OFF));
    }
}

Tiré de cette réponse

Pour info: étant donné que votre "écran de verrouillage" sera toujours considéré comme faisant partie de votre lanceur à ce stade, les applications pourront se lancer au-dessus de votre écran de verrouillage, ce qui est mauvais si: l'utilisateur a accès à la notification tiroir pour cliquer sur les messages/Tweets etc, mais peut aussi être bon pour: pouvoir répondre aux appels entrants sans déverrouiller le téléphone.

Quoi qu'il en soit, votre activité d'écran de verrouillage doit remplacer onPause, vérifier si l'utilisateur est "authentifié", sinon, supposer que l'utilisateur a ouvert quelque chose et revenir à l'écran de verrouillage:

@Override
public void onPause() {
    super.onPause();
    if(password!=storedPassword) {
      //Lockscreen activity shouldn't ever be escaped without the right password!
      //Return to launcher without root!
      Intent homeIntent = new Intent(Intent.ACTION_MAIN);
      homeIntent.addCategory(Intent.CATEGORY_HOME);
      homeIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
      startActivity(homeIntent);
    }
}

Pour une meilleure expérience utilisateur, vous devez donner à votre utilisateur la possibilité d'autoriser quelques applications à contourner l'écran de verrouillage (comme Spotify), vous pouvez l'inclure dans l'instruction if ci-dessus (ex. if(password!=storedPassword||isForegroundAppSpotify)).

En ce qui concerne le chargement des applications sur votre écran d'accueil, vous pouvez vous référer à tutoriels sur Google pour créer votre propre activité de lancement.

La combinaison lanceur + écran de verrouillage est le moyen le plus simple d'éviter l'accès root. Vous pouvez trouver plus facile d'utiliser root, mais vous limitez votre clientèle.

J'espère que cela t'aides!

3
Aaron Gillion

J'ai fait beaucoup de recherches pour concevoir un écran de verrouillage et j'ai finalement trouvé une solution. Android a désactivé la fonctionnalité pour remplacer les barres système à l'exception du bouton Précédent. Mais il y a un peu de travail pour faire fonctionner cela:

Comprenez et mettez en œuvre l'épinglage d'écran patiemment et vous réussirez.

Vous pouvez créer une application pour contrôler toutes les applications dans lesquelles vous souhaitez implémenter l'épinglage d'écran ou vous pouvez implémenter l'épinglage d'écran directement dans la même application que vous souhaitez épingler.

Je vais vous montrer l'implémentation ultérieure dans cet article:

1. Tout d'abord, votre application doit être le propriétaire de l'appareil.

Vous pouvez le faire de plusieurs manières et le plus simple est d'exécuter la commande:

adb Shell dpm set-device-owner [yourPackageName] /. [MyDeviceAdminReceiver]

Créez un récepteur (MyDeviceAdminReceiver) qui étend DeviceAdminReceiver. Vous n'avez pas besoin d'avoir de code ici. Pour plus d'informations sur la mise en œuvre du propriétaire de l'appareil, consultez ce lien
http://florent-dupont.blogspot.com/2015/02/10-things-to-know-about-device-owner.html

Enregistrez le récepteur dans le fichier AndroidManifest.xml de cette façon:

<receiver
       Android:name=".MyDeviceAdminReceiver"
       Android:label="@string/app_name"
       Android:permission="Android.permission.BIND_DEVICE_ADMIN">
     <meta-data
       Android:name="Android.app.device_admin"
       Android:resource="@xml/device_admin" />

       <intent-filter>
         <action Android:name="Android.app.action.DEVICE_ADMIN_ENABLED" />
       </intent-filter>
  </receiver>

2. Votre méthode onCreate devrait ressembler à ceci: 

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_lock_screen);

    ComponentName deviceAdmin = new ComponentName(this, MyDeviceAdminReceiver.class);
    DevicePolicyManager mDpm = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);


    if (mDpm.isDeviceOwnerApp(getPackageName())) {
        mDpm.setLockTaskPackages(deviceAdmin, new String[]{getPackageName()});
    }

    if (mDpm.isLockTaskPermitted(this.getPackageName()))
        startLockTask();

3.Pour détacher l'écran et rendre la barre de navigation fonctionnelle :

Appelez la fonction stopLockTask () à un endroit de votre code où vous souhaitez annuler l'épinglage. Par exemple dans mon application, dès que je vérifie que l'utilisateur a tapé le bon mot de passe, j'appelle cette fonction:

 if (userInput.length() == 4) {

                    if (userInput.equals(passcode)) {
                        userInput = "";
                        etxtPasscodeDisplay.setText("");
                        stopLockTask(); // this is what you need
                        unlockHomeButton(); // A method to show home screen when 
                         passcode is correct
                        finishAffinity(); //kill other activities
                    }

Informations supplémentaires généralement requises pour les écrans de verrouillage:

1. Si votre application est la première chose qui apparaît après le démarrage :

Vous avez besoin d'un service (StartAtBootService) et d'un récepteur (BootCompletedReceiver) pour cela.

2. Si vous souhaitez que votre application apparaisse après le verrouillage et le déverrouillage de l'écran (le bouton d'alimentation est enfoncé pour verrouiller et déverrouiller):

Créez AEScreenOnOffService qui étend le service et AEScreenOnOffReceiver qui étend BroadcastReceiver pour lancer votre activité lorsque l'écran est allumé.

Pour une information détaillée sur tout ce que j'ai mentionné ici, consultez http://www.sureshjoshi.com/mobile/Android-kiosk-mode-without-root/
Ceci est une excellente rédaction qui m'a beaucoup aidé. Remerciements particuliers à l'auteur.

J'ai besoin d'au moins 10 points de réputation pour publier plus de deux liens. Comme je suis nouveau sur stackoverflow, je n'ai pas assez de réputation, donc je suis désolé de ne pas pouvoir partager tous les liens que j'ai référés. Va sûrement mettre à jour le message une fois que j'aurai accès.

2
Nithesh

Vous pouvez utiliser la bibliothèque shaobin0604 pour ce faire. Cela désactivera également le bouton Retour. Votre activité ressemblera à ceci:


public class MainActivity extends Activity {

HomeKeyLocker homeKeyLocker;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    homeKeyLocker = new HomeKeyLocker();
    homeKeyLocker.lock(this);
}
</code>

}
2
Jordan Junior

La réponse simple à votre question est que vous ne pouvez pas faire cela.

La solution que vous avez mentionnée a été suggérée par moi il y a environ quatre ans [Link] .

onUserLeavesHint, onKeyDown et onKeyDispatch ne "désactiveront" jamais les clés matérielles.

Si vous voulez vraiment "gérer" le bouton Accueil, vous devrez faire votre demande comme écran d'accueil. Voir ce et ce .

Si vous voulez vraiment désactiver votre clé matérielle sans créer d'application d'écran d'accueil, vous devez rooter votre appareil et supprimer le fichier de périphérique correspondant du module du noyau. (Essayez à vos risques et périls!)

1
PC.