L'intention peut soit spécifier le composant à démarrer, soit laisser le système Android décider quel composant démarrer. La première est appelée une intention explicite et la seconde est appelée une intention implicite. Dans la méthode de confier le composant à démarrer au système Android, les informations (\ ) sont décrites dans le manifeste de l'application ayant le composant à rechercher afin que le système Android puisse rechercher le composant.
En définissant une action simple et les données nécessaires dans l'objet Intent implicite, vous pouvez démarrer la possibilité d'exécuter l'action dans une autre application. Vous n'avez pas besoin de spécifier le composant à exécuter.
Ce qui suit décrit les intentions implicites qui exécutent des actions générales pour chaque type d'application qui peut gérer les intentions.
COUTION
Si vous n'avez pas d'application sur votre appareil qui peut utiliser Intent implicite, l'utilisation de startActivity () provoquera le blocage de l'application. Pour éviter un plantage, appelez la méthode resolutionActibity () (la méthode de l'objet Intent) pour vérifier l'existence de l'application qui peut recevoir l'intention. Si le résultat n'est pas nul, il existe une application qui peut recevoir Intent et vous pouvez appeler startActivity () en toute sécurité. Si le résultat est nul, l'intention provoquera un plantage, alors ne l'utilisez pas. font> td> table>
Intent et IntentFilter
https://developer.android.com/guide/components/intents-filters.html?hl=ja
L'intention facilite la communication entre les composants. Les trois exemples suivants sont des exemples d'utilisation de base.
Exemple d'utilisation d'intention
- Démarrer l'activité </ strong>
Pour démarrer une nouvelle instance d'activité (créer un nouvel écran), transmettez Intent to startActivity () </ font> .. L'activité à démarrer est décrite dans l'intention et les données nécessaires sont définies. Utilisez startActivityForResult () </ font> pour recevoir le résultat lorsque l'activité est terminée. L'activité reçoit le résultat en tant qu'objet Intent en utilisant le rappel onActivityResult () </ font>.
- Service start </ strong>
Le service est un composant pour les opérations en arrière-plan sans interface utilisateur. Avec Android5.0 (API21) ou version ultérieure, vous pouvez démarrer le service avec JobScheduler </ font>. Dans Android5.0 ou version antérieure, démarrez le service avec la méthode de la classe Service. Pour les opérations ponctuelles telles que le téléchargement de fichiers, transmettez Intent à startService (). Configurez le service et les données pour démarrer dans Intent. Si l'interface client-serveur est définie pour le service, l'intention peut être transmise à bindService () </ font> et liée au service d'autres composants.
- Diffusion de la diffusion </ strong>
La diffusion est un message qui peut être reçu par n'importe quelle application. Le système diffuse des émissions sur divers événements du système tels que le démarrage du terminal et le début de la charge. Pour diffuser vers d'autres applications, transmettez l'intention à sendBroadcast () </ font> ou sendOrderedBroadcast () </ font>.
Type d'intention | Intention explicite Intention implicite
- Explicit Intent </ strong>
Spécifiez le nom du package de l'application cible ou le nom complet de la classe de décoration du composant et spécifiez l'application qui exécute l'intention. Dans de nombreux cas, le développeur utilise une intention explicite car il connaît le nom de classe de l'activité ou du service qu'il souhaite démarrer.
- Intention implicite </ strong>
Ne nommez pas de composant spécifique. En définissant le traitement et les données nécessaires dans l'intention, il peut être exécuté par un composant d'une autre application. Par exemple, si vous souhaitez afficher un certain lieu sur la carte à l'utilisateur, demandez à l'aide de l'intention d'afficher le lieu spécifié par une autre application sur la carte.
Utilisez une intention implicite lorsque vous confiez le composant qui gère l'activité au système Android, et une intention explicite lorsque le composant est spécifique (non confié au système).
\ <Fonctionnement de l'intention: Image> </ strong>
1. Activity (A) crée un Intent qui décrit l'action et le transmet à startActivity () (startActivity (intent))
2. Le système Android recherche toutes les applications et trouve les filtres d'intention qui correspondent à l'intention
3. Si un filtre d'intention correspondant est trouvé, le système appelle la méthode onCreate () de l'application et transmet l'intent font> strong>
4. L'application recherchée démarre une activité (B) qui correspond à l'intention.
|
Avec l'intention implicite, le système Android compare le contenu de l'intention avec le filtre d'intention défini dans le fichier manifeste d'autres applications </ font>. Lorsque l'intention correspond au filtre Intent, le système Android démarre son composant et délivre l'objet Intent. S'il existe plusieurs applications correspondantes, laissez l'utilisateur les sélectionner dans la boîte de dialogue. Le filtre d'intention spécifie le type d'intention que le composant souhaite recevoir dans le fichier manifeste de l'application.
Par exemple, vous pouvez déclarer un filtre d'intention d'activité pour démarrer une activité directement à partir d'une autre application à l'aide d'un type particulier d'intention. Si vous ne déclarez pas de filtre d'intention pour l'activité, vous ne pouvez démarrer l'activité qu'avec une intention explicite.
COUTION
Utilisez une intention explicite lorsque vous démarrez avec Service. N'utilisez pas le filtre d'intention du service. L'intention implicite dans un service présente un risque de sécurité car elle perd la trace du fait que le service répond à l'intention et que l'utilisateur n'est pas au courant du service lancé. Dans Android 5.0 et versions ultérieures, l'utilisation de bindService () avec une intention implicite provoque le déclenchement d'une exception par le système. td> table>
Construire l'intention
Dans l'objet Intent, définissez les informations requises pour rechercher le composant démarré par le système Android et les informations requises pour que le composant exécute l'action (ci-dessous).
- Nom du composant
- Action
- Données
- Catégorie
- Extra
- Drapeau
Intent intent = new Intent(this,MainActivity.class);
intent.setComponent() // setClass(),setClassName(),Intent Constructor
intent.setAction() // Intent Constructor
intent.setData() // setType setDataAndType
intent.CATEFORY_BROWSABLE // CATEGORY_LAUNCHER
intent.putExtar()
intent.setFlags()
// Android Developer intent :des constructeurs publics(Context packageContext, Class<?> cls)référence
//Composant spécifié(Class<?>)Créer une intention dans
//Le contexte est AndroidSystem<-> app :Passer les informations sur l'environnement
■ Nom du composant (objet ComponentName)
- Nom du composant de départ </ strong>
Requis pour les intentions explicites. En outre, lors du démarrage du service, utilisez une intention explicite pour garantir la sécurité.
--L'objet ComponentName peut être spécifié en utilisant le nom de classe entièrement décoré du composant cible (par exemple com.example.ExampleActivity). Spécifiez avec la méthode suivante, etc.
- setComponent()
- setClass()
- setClassName()
- Constructeur d'intention
■ Action
Une chaîne qui spécifie l'action générale (affichage ou sélection) effectuée.
-
Pour l'intention de diffusion, cette chaîne est une action qui s'est déjà produite et qui a été signalée. Les informations qui constituent d'autres intentions, telles que les informations contenues dans les données et les extras, sont déterminées par le type d'action (affichage ou sélection).
-
Dans votre application, l'action à démarrer est spécifiée par Intent, ou elle est spécifiée par Intent pour appeler le composant de votre application à partir d'autres applications, mais Normalement Intent Spécifiez les constantes d'action définies dans la classe ou dans d'autres classes du framework </ font>.
-
<Constantes d'action générales pour démarrer une activité> </ strong>
-
ACTION_VIEW </ font> </ strong> Lorsqu'il existe des informations que l'activité affiche à l'utilisateur, telles que la photo affichée dans l'application ou l'adresse affichée dans l'application de carte. En outre, utilisez la constante ACTION_VIEW </ font> pour l'intention et transmettez-la à startActivity ().
-
ACTION_SEND </ font> </ strong> ACTION_SEND est intention partagée </ font>. Si des données peuvent être partagées avec une autre application, telle qu'une application de messagerie ou une application de partage social, utilisez la constante ACTION_SEND </ font> pour Intent et transmettez-la à startActivity ().
Les constantes qui définissent d'autres actions sont> https://developer.android.com/reference/android/content/Intent.html?hl=ja (voir Contenu)
D'autres actions sont définies ailleurs dans le framework Android. Par exemple, l'action pour ouvrir un écran spécifique de l'application des paramètres système est définie dans Paramètres.
Les actions d'intention sont spécifiées à l'aide de setAction () ou du constructeur d'intention </ font>.
Ci-dessous, après avoir défini votre propre action (TIMETRAVEL), spécifiez le nom du package de l'application comme préfixe (ACTION_TIMETRAVEL = " com.example.action.TIMETRAVEL " ).
static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";
■ Données
Un URI (objet Uri) qui fait référence aux données requises pour exécuter une action et au type MINE des données. Le type de données spécifié dépend de l'action de l'intention. Si l'action est ACTION_EDIT </ font>, les données seront définies sur l'URI du document à modifier.
Lors de la création d'une intention, il peut être important de spécifier le type de données (MIME) </ font> ainsi que l'URI. La musique ne peut pas être lue dans l'activité d'affichage d'image. Spécifiez le type MIME des données pour permettre au système Android de rechercher les composants appropriés pour l'intention.
Cependant, il peut être possible d'estimer MIME à partir de l'URI. Lorsque les données sont du contenu, l'URI se trouve sur le terminal et est contrôlé par ContentProvider, de sorte que le système Android peut déterminer le type MIME à partir de l'URI.
<Paramètre de type de données / MIME>
--Définir uniquement l'URI des données: setData () </ font>
- Définir le type MIME uniquement: setType () </ font>
- Définissez les deux: utilisez setDataAndType ().
COUTION Lors de la définition du type URI et MIME, n'utilisez pas setData () et setType () (désactivez les valeurs de l'autre) Il y a un risque). Lorsque vous définissez les deux, veillez à utiliser setDataAndType () font> td> table>
■ Catégorie
Chaîne qui définit des informations supplémentaires sur le type de composant qui gère l'intention. La plupart des intentions ne nécessitent pas de catégories. Vous pouvez définir autant de descriptions de catégories que vous le souhaitez dans Intention. Voici quelques exemples de catégories couramment utilisées.
- CATEFORY_BROWSABLE
En fonction de l'activité cible, le navigateur affiche des données telles que des images et des e-mails.
- CATEGORY_LAUNCHER
Dans l'activité initiale de la tâche, affichez l'activité dans la liste des lanceurs d'application du système.
■ Extra
Par nom de composant, action, données ou catégorie, le système Android recherche le composant d'application approprié. Des informations supplémentaires qui n'affectent pas cette recherche peuvent être trouvées dans les Extras d'intention </ font>.
Définissez les informations requises pour exécuter l'action de demande avec une paire clé / valeur. Les actions utilisent certains types d'URI de données ou utilisent certains extras.
Les données supplémentaires sont la méthode putExtra () </ font>, qui ajoute des paramètres de clé et de valeur. Bundle </ font> peut définir toutes les données supplémentaires, et putExtras () peut être utilisé pour définir Bundle sur Intent </ font>.
Par exemple, lors de la création d'une intention d'envoyer un e-mail à l'aide de ACTION_SEND </ font>, utilisez la clé EXTRA_EMAIL </ font> au destinataire Ou vous pouvez spécifier le sujet à l'aide de la touche EXTRA_SUBJECT </ font>.
La classe Intent peut spécifier plusieurs constantes EXTRA_ * </ strong> pour les types de données standardisés. Si vous souhaitez déclarer votre propre clé supplémentaire pour l'intention que votre application reçoit, spécifiez le nom du package de l'application comme préfixe (ci-dessous).
static final String EXTRA_GIGAWATTS = "com.example.EXTRA_FIFAWATTS";
COUTION:
N'utilisez pas Parcelable ou Serializable lors de l'envoi d'intentions reçues par d'autres applications. Si l'application tente d'accéder aux données de l'objet Bundle et ne peut pas accéder aux classes de parcellisation ou de sérialisation, le système lève une RuntimeException. font> td> table>
■ Drapeau
Défini dans la classe d'intention d'indicateur. L'indicateur fonctionne comme des métadonnées d'intention (informations indiquant les données elles-mêmes (nom, date, extension, etc.) telles que les fichiers et les dossiers). L'indicateur spécifie au système Android comment démarrer l'activité (à quelle tâche l'activité appartient, etc.) et comment la gérer après le démarrage (s'il faut l'inclure dans la liste des activités récentes, etc.).
□ setFlags
--Définissez la gestion de l'intention avec l'indicateur. Les paramètres dépendent du type de composant exécuté par Intent. L'indicateur ** FLAG_ACTIVITY_ * ** est utilisé dans ** ConText # startActivity **, et l'indicateur ** FLAG_RECEIVER_ * ** est utilisé dans ** Context # sendBroadcast (Intent) **. (Par exemple, si vous définissez FLAG_ACTIVITY_NO_HISTORY, les nouvelles activités ne seront pas enregistrées dans l'historique de la pile)
--setFlags () Pour plus d'informations> https://developer.android.com/reference/android/content/Intent.html?hl=ja#setFlags (int)
Intention explicite, exemple d'intention implicite
Exemple d'intention explicite
Utilisez une intention explicite lors du lancement de composants d'application spéciaux. Pour créer une intention explicite, définissez le nom du composant dans l'objet Intent. Les autres propriétés Intent sont facultatives.
<Exemple: Démarrez Download Service pour télécharger des fichiers à partir du Web>
//Supposons que vous souhaitiez participer à une activité.'this'Est le contexte.
//fileUrl est l'URL de la chaîne.("http:://www.example.com/image.png ")
Intent downloadIntent = new Intent(this,DownloadService.class);
downloadIntent.setData(Uri.parse(fileUrl));
startService(downloadIntent);
Le constructeur Intent (Context, Class) fournit le contexte à l'application et l'objet Class au composant. De cette manière, cette intention lance explicitement la classe DownloadService vers l'application.
Exemple d'intention implicite
L'intention implicite lance une application sur un appareil qui peut spécifier une action et l'exécuter. L'intention implicite est un bon choix si vous ne souhaitez pas effectuer cette action dans votre propre application, mais que vous pouvez le faire dans une autre application et que vous souhaitez que l'utilisateur choisisse d'utiliser ou non cette application.
Par exemple, si vous avez du contenu que vous souhaitez que les utilisateurs partagent avec d’autres, utilisez l’action ACTION_SEND </ font> pour créer une intention et ajoutez un élément supplémentaire pour spécifier le contenu à partager. Faire. L'utilisation de cette intention pour appeler startActivity () </ font> permet à l'utilisateur de choisir avec quelle application partager le contenu.
COUTION:
Il se peut qu'aucune application ne puisse gérer l'intention implicite envoyée à startActivity (), ou elle peut être inaccessible en raison de restrictions de fichiers ou de paramètres. Dans ce cas, l'application plantera. Pour éviter un plantage, certaines activités utilisent resolActivity () strong> sur l'objet Intent et utilisent Intent si le résultat n'est pas nul. Si null, désactivez le processus d'émission d'intention pour éviter un blocage. Le code ci-dessous est un exemple. Dans cet exemple, le contenu supplémentaire est spécifié en déclarant le type de données Intent sans utiliser l'URI. font> td> table>
python
//Générer un message texte avec une chaîne
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT,textMessage);
sendIntent.setType("text/plain");
//Vérifiez s'il y a une activité qui utilise l'intention
if(sendIntent.resolbeActivity(getPackageManager()) !=null){
startActivity(sendIntent);
}
Lorsque startActivity () est appelée, le système examine toutes les applications installées et détermine quelles applications peuvent gérer ce type d'intention. L'intention doit avoir l'action ACTION_SEND </ font> et l'ensemble de données "text / plain". S'il existe plusieurs activités de ce type, laissez l'utilisateur sélectionner l'activité à démarrer dans la boîte de dialogue (boîte de dialogue Tuser).
Affichage du sélecteur d'applications
Lorsque plusieurs applications répondent à une intention implicite, l'utilisateur sélectionne l'application et en fait le choix d'action par défaut. La définition des choix par défaut est utile si l'utilisateur sélectionne la même application à chaque fois.
Cependant, s'il existe plusieurs applications qui répondent à l'intention et que l'utilisateur peut utiliser une application différente à chaque fois, affichez explicitement la boîte de dialogue de sélection (l'application par défaut pour l'action ne peut pas être sélectionnée).
Lorsqu'une application effectue un "partage" avec une action ACTION_SEND </ font>, l'utilisateur peut souhaiter partager à l'aide d'une autre application, selon la situation du moment. Utilisez toujours une boîte de dialogue de sélection comme celle ci-dessous.
Code d'affichage Tuser
Créez une intention à l'aide de createChooser () </ font> et transmettez-la à startActivity () </ font>. Le code suivant affichera dans une boîte de dialogue une liste d'applications qui répondent à l'intention transmise à la méthode createChooser () </ font>. Utilisez le texte spécifié pour le titre de la boîte de dialogue.
python
Intent sendIntent = new Intent(Intent.ACTION_SEND);
...
// "Utilisez cette application ●●"Avec ce sentiment
//Utiliser des ressources de chaîne pour le texte de l'interface utilisateur
String title = getResources().getString(R.string.chooser_title);
//Générer une intention qui affiche la boîte de dialogue de sélection
Intent chooser = Intent.createChooser(sendIntent,title);
//L'intention implicite nécessite la présence d'une action de réponse
//Vérifiez s'il y a une action pour répondre
if(sendIntent.sesolveActivity(getPackageManager())!=null){
startActivity(chooser);
}
Recevoir une intention implicite
Pour annoncer l'intention implicite que votre application peut recevoir, utilisez l'élément </ font> dans le fichier manifeste pour filtrer un ou plusieurs filtres d'intention pour chaque composant d'application. Déclarer. Chaque filtre d'intention spécifie le type d'intention qu'il accepte, en fonction des actions, des données et des catégories de l'intent. Le système délivre une intention implicite à ses composants d'application uniquement si l'intention passe l'un des filtres d'intention.
L'intention explicite est toujours fournie au composant cible, quel que soit le filtre d'intention déclaré par le composant.
|
Le composant d'application déclare un filtre individuellement pour chaque tâche unique à exécuter. Par exemple, si une activité de l'application de galerie d'images a deux filtres, l'un pour afficher l'image et l'autre pour la modifier, lorsque vous démarrez cette activité, elle reviendra aux informations de l'intention et affichera ou modifiera l'image. Décidez quelle action choisir.
Chaque filtre d'intention est défini dans l'élément </ font> du fichier manifeste de l'application et correspond au composant de l'application ( < Nest dans les éléments d'activité> </ font>, etc.). Dans </ font>, utilisez un ou plusieurs des trois éléments suivants et spécifiez le type d'intention à accepter.
-
\ </ font> </ strong> Dans l'attribut name, déclarez l'action de l'intention d'accepter. La valeur doit être la chaîne littérale de l'action ("Utiliser cette ●● action").
-
\ </ font> </ strong> URI de données (schéma / hôte / port / chemin) et un ou plusieurs attributs de différents types MIME Utilisez pour déclarer le type de données à accepter.
-
\ </ font> </ strong> Dans l'attribut name, déclarez la catégorie Intent à accepter. La valeur est la chaîne littérale de l'action. Pour recevoir une intention implicite, incluez la catégorie CATEGORY_DEFAULT </ strong> dans le filtre d'intention. Les méthodes startActivity () </ strong> et startActivityForResult () </ strong> traitent tous les Intents comme s'ils déclaraient une catégorie CATEGORY_DEFAULT </ strong>. Faire. Si le filtre d'intention ne déclare pas la catégorie CATEGORY_DEFAULT </ strong>, il détermine qu'aucune activité ne répond à l'intention implicite </ font> </ table>
La déclaration d'activité du filtre d'intention qui reçoit l'intention ACTION_SEND </ font> lorsque le type de données est texte est illustrée ci-dessous.
manifest.java
<activity ancroid:name="ShareActivity">
<intent-filter>
<action ancroid:name = "android.intent.action.SEND"/>
<category android:name = "android.intent.category.DEFAULT"/>
<data android:mimeType = "text/plain"/>
</intent-filter>
</activity>
Vous pouvez créer un filtre contenant au moins deux des éléments suivants: \ \ \ </ font>. À ce stade, vous devez vous assurer que le composant peut gérer toute combinaison de ces éléments de filtre </ font>.
Si vous souhaitez prendre en charge plusieurs types d'intentions et ne gérer que des combinaisons spécifiques de types de catégorie de données d'action </ strong>, vous devez créer plusieurs filtres d'intention.
L'intention implicite est déterminée pour adapter chacun de ces trois éléments et l'intention à un filtre. Lorsque l'intention passe le jugement de conformité des trois éléments, l'intention est délivrée au composant. Si même un ne correspond pas, le système Android ne fournira pas l'intention. Cependant, si plusieurs filtres d'intention sont définis pour un composant, l'un des filtres peut être passé.
COUTION: Les filtres d'intention peuvent être dangereux pour empêcher d'autres applications d'utiliser les composants de votre application. Le filtre d'intention limite un composant à répondre uniquement à certains types d'intentions implicites, mais si une autre application spécifie un composant pour son application et utilise une intention explicite, le composant peut démarrer. Il y a du sexe. Pour éviter qu'il ne soit utilisé par une autre application, définissez l'attribut exporté du composant sur "false" au lieu d'utiliser le filtre d'intention dans le manifeste font> < / fort>. Démarrez toujours votre service avec une intention explicite d'éviter d'exécuter accidentellement les services d'autres applications. font> td> table>
Déclarez un filtre d'intention dans le fichier manifeste pour toutes les activités. Cependant, les filtres de récepteur de diffusion peuvent être enregistrés dynamiquement en appelant registerReceiver () strong>. Utilisez ensuite unregisterReceiver () strong> pour désinscrire le récepteur. Cela permet à l'application d'écouter une diffusion particulière pendant une période de temps spécifique pendant que l'application est en cours d'exécution. td> table>
Exemple de filtre
Le fonctionnement du filtre d'intention sera expliqué en utilisant le fichier manifeste de l'application de partage social comme exemple.
python
<activity android:name="MainActivity">
<!--Activité principale pour lancer l'application depuis le lanceur-->
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="ShareActivity">
<!--Activités qui gèrent le processus d'envoi de données textuelles-->
<intent-filter>
<action android:name ="android.intent.action.SEND"/>
<category android:name ="android.intent.category.DEFAULT"/>
<data android:mimeType="text/plain"/>
</intent-filter>
<!--Activité pour envoyer des données multimédias-->
<intent-filter>
<action android:name="android.intent.action.SEND"/>
<action android:name="android.intent.action.SEND_MULTIPLE"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:mimeType="application/vnd.google.panorama360+jpg"/>
<data android:mimeType="image/*"/>
<data android:mimeType="video/*"/>
</intent-filter>
</activity>
Le premier filtre d'intention est l'activité principale, l'activité qui s'ouvre la première fois que l'utilisateur lance l'application à partir de l'icône du lanceur.
- ACTION_MAIN </ font> </ strong> Action
Le point d'entrée principal indique qu'il n'y a pas de données d'intention.
- Catégorie CATEGORY_LAUNCHER </ font> </ strong>
Indique que l'icône de cette activité doit être placée dans le lanceur d'applications du système.
-Si l'élément \ </ font> est une icône et qu'aucune icône n'est spécifiée, le système utilisera l'élément \ </ font>. Utilisez l'icône.
Pour afficher cette activité dans le lanceur d'applications, associez les deux.
La deuxième activité, «ShareActivity», facilite le partage de texte et de contenu multimédia. L'utilisateur peut entrer dans cette activité en naviguant à partir de MainActivity , mais émet une intention implicite qui correspond à l'un des deux filtres d'intention (filtre d'intention de données de texte ou filtre d'intention de données de média). Vous pouvez également entrer «ShareActivity» directement à partir d'une autre application.
Le type d'application MIME / vnd.google.panorama360 + jpg est un type de données spécial qui spécifie une photo panoramique et est traité par l'API Google Panorama. td> table>
Utiliser PendingIntent
L'objet PendingIntent </ font> est un wrapper pour l'objet Intent. L'objectif principal est de donner à une autre application l'autorisation d'utiliser l'intention contenue comme si elle avait été effectuée à partir du processus de développement de l'application.
Principaux cas d'utilisation de PendingIntent
En attente signifie en attente. C'est comme utiliser Intent à un moment donné au lieu de l'utiliser tout de suite.
--Utilisez les notifications pour déclarer une intention à utiliser lorsqu'un utilisateur effectue une action (le gestionnaire de notifications sur le système Android exécute l'intention).
-
Utilisez le widget de l'application pour déclarer l'intention que l'utilisateur utilisera pour effectuer l'action (l'application de l'écran d'accueil exécutera l'intention).
-
Déclarez une intention pour qu'une action soit exécutée à un moment spécifié dans le futur (AlarmManager sur le système Android exécute l'intention).
Étant donné que chaque objet Intent est supposé être traité par un type spécifique de composant de l'application, PendingIntent est créé sur la même hypothèse. Lorsque PendingIntent est utilisé, l'application à développer n'exécute pas Intent en appelant startActivity () </ font>. Au lieu de cela, appelez la méthode de génération suivante pour déclarer le type de composant souhaité lors de la création de PendingIntent.
- Intention de démarrer l'activité </ font> </ strong>
PendingInten.getActivity ()
- Intention de démarrer le service </ font> </ strong>
PendingIntent.getService ()
- Démarrer l'intention BroadcastReceiver </ font> </ strong>
PendingIntent.getBroadcast ()
À moins que l'application que vous développez ne reçoive un PendingIntent d'une autre application, les méthodes PendingIntent requises lors de la création d'un PendingIntent sont presque les trois ci-dessus (il existe également getActivities (Context, int, Intent [], int)).
Chaque méthode reçoit un Contexte </ font> pour l'application actuelle, l'intention que vous souhaitez encapsuler et un ou plusieurs indicateurs (si l'intention peut être utilisée plusieurs fois) qui spécifie comment utiliser l'intention.
PendingIntent developers
Une description des intentions et des actions effectuées par PendingIntent.
Créez une instance de la classe PendingIntent avec la méthode suivante.
- getActivity(Context,int,Intent,int)
- getActivities(Context,int,Intent,int)
- getBroadcast(Context,int,Intent,int)
- getService(Context,int,Intent,int)
Description de l'argument </ strong>
getActivity (activité démarrée avec PendingInten, code privé PendingIntent Source, intention d'exécuter, indicateur)
L'instance PendingIntent créée fonctionne pour exécuter d'autres applications après coup.
Lorsque PendingIntent est passé à une autre application, l'application transmise reçoit la même autorisation d'exécution que l'application source de distribution elle-même (il est déterminé qu'elle a la même autorisation et le même ID). Par conséquent, vous devez faire attention à la façon de générer PendingIntent. Par exemple, lors de l'émission d'une intention de base, un nom de composant explicite est donné afin que l'intention puisse être livrée au composant de destination du problème sans erreur. (Ne donnez pas de privilèges importants à la mauvaise destination de livraison)
Pour plus d'informations sur l'utilisation de PendingIntent, consultez les exemples d'utilisation ci-dessous.
https://developer.android.com/guide/topics/ui/notifiers/notifications.html?hl=ja
https://developer.android.com/guide/topics/appwidgets/index.html?hl=ja
Jugement de réponse implicite Inten
Lorsque le système reçoit une intention implicite qui lance une activité, il compare l'intention avec le filtre Intention pour trouver la meilleure activité pour l'intention.
- Action
--data (URI et type de données)
- category
Test d'intention d'action implicite
Pour spécifier les actions d'intention à accepter, déclarez zéro ou plusieurs éléments \ </ font> dans le filtre d'intention.
python
<intent-filter>
<action android:name="android.intent.action.EDIT"/>
<action android:name="android.intent.action.VIEW"/>
...
</intent-filter>
Pour passer ce filtre, l'action spécifiée par Intent doit correspondre à l'action toute </ font> action spécifiée par \ .
S'il n'y a aucune action dans la liste des filtres (\ ~ </ intent-filter>), alors il n'y a pas de correspondance pour l'intention et toutes les intentions ne peuvent pas passer le test. Cependant, lorsque l'intention ne spécifie pas d'action, si le filtre a une ou plusieurs actions, le test réussit.
Test de catégorie d'intention implicite
Lorsque vous spécifiez une catégorie, déclarez 0 ou plusieurs éléments \ </ font> dans le filtre Intention.
python
<intent-filter>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
...
</intent-filter>
Toutes les catégories d'intention doivent correspondre aux catégories du filtre pour que l'intention réussisse le test de catégorie. S'il y a plus de catégories spécifiées par le filtre Intention que les catégories spécifiées par Intent, Intent peut réussir. Par exemple, une intention sans catégorie réussira toujours le test, quelle que soit la catégorie déclarée dans le filtre.
Catégorie CATEGORY_DEFAULLT strong> automatiquement pour tous les Intents implicites transmis à startActivity () et startActivityForResult () strong> S'adapter à Si vous souhaitez que votre activité reçoive une intention implicite, placez la catégorie "android.intent.category.DEFAULT" strong> dans \ Doit être inclus font>. td> table>
Test de données d'intention implicite
Si vous souhaitez spécifier les données d'intention à accepter, déclarez zéro ou plusieurs éléments \ </ font> dans le filtre d'intention.
python
<intent-filter>
<data android:mimeType="video/mpeg" android:scheme="http" .../>
<data android:mimeType="audio/mpeg" android:scheme="http" .../>
///
</intent-filter>
Chaque élément vous permet de spécifier la structure URI et le type de données (type de média MIME). L'URI se compose de quatre attributs, chemin du port d'hôte du schéma </ font>, comme illustré ci-dessous.
<scheme>://<host>:<port>/<path>
L'exemple suivant décrit les valeurs possibles pour ces attributs.
content://com.example.project:200/folder/subfolder/etc
Dans cet URI, le schéma est "content", l'hôte est "com.example.project", le port est "200" et le chemin est "dossier / sous-dossier / etc".
Chacun de ces attributs peut être omis dans l'élément \ </ font>. Cependant, il existe une dépendance principale.
--Ignorer l'hôte si le schéma n'est pas spécifié
--Si l'hôte n'est pas spécifié, le port est ignoré
--Ignorer le chemin si le schéma et l'hôte ne sont pas spécifiés
Lors de la comparaison de l'URI de l'intention avec la spécification d'URI du filtre, il ne compare qu'une partie de l'URI contenu dans le filtre.
--Si seul un schéma est spécifié dans le filtre, tous les filtres avec ce schéma correspondent.
- Si le schéma de filtre et l'hôte sont spécifiés et qu'aucun chemin n'est spécifié, tous les URI avec le même schéma et l'hôte passeront le filtre.
- Si le filtre spécifie le schéma, l'hôte, le chemin, seuls les URI avec le même schéma, l'hôte, le chemin passeront le filtre.
Selon la spécification du chemin, il est possible de ne demander qu'une correspondance partielle du nom du chemin, y compris l'astérisque générique (*). td> table>
Le test de données compare à la fois l'URI et le type MIME de l'intention avec les valeurs spécifiées dans le filtre. Les règles ou comme suit.
- Lesintentes sans URI ou type MIME ne peuvent réussir le test que si le filtre ne spécifie pas de type URI ou MIME.
- Tester uniquement si l'URI est spécifié et que le type MIME est non spécifié Intention (le type n'est pas spécifié et ne peut pas être déduit de l'URI), l'URI correspond au format URI du filtre et le filtre ne spécifie pas le type MIME Passer
--Si l'URI n'est pas spécifié et le type MIME est spécifié, le test réussit uniquement si la liste de filtres a le même type MIME et le format d'URI n'est pas spécifié.
--Pour les intentions avec un URI et un type MIME spécifiés (explicites, déduits de l'URI), passez le test de type MIME uniquement si le type MIME correspond au type dans la liste de filtres.
Le test URI réussit le test s'il correspond à l'URI du filtre ou si l'intention a le contenu: URI ou fichier: URI et que le filtre ne spécifie pas l'URI. Autrement dit, si le filtre répertorie uniquement les types MIME, nous supposons que le composant prend en charge contenu: données et fichier: données.
Si l'intention spécifie un type URI ou MIME, le test de données échouera s'il n'y a pas d'élément dans \ table> td> table>
La dernière règle est une règle qui suppose que le composant peut obtenir des données locales à partir de fichiers et de fournisseurs de contenu. Le filtre répertorie uniquement les types de données et il n'est pas nécessaire de spécifier explicitement le contenu: schéma ou fichier: schéma. L'exemple suivant est un code typique qui montre que l'élément peut accéder à Androido et que le composant peut obtenir les données d'image du fournisseur de contenu et les afficher.
python
<intent-filter>
<data android:mimeType="image/*"/>
...
</intent-filter>
La plupart des données disponibles sont fournies par le fournisseur de contenu (partage d'informations, interface pour connecter les données d'un processus au code exécuté dans un autre processus). Spécifiez donc le type de données et l'URI. La méthode qui ne spécifie pas est souvent utilisée (le fournisseur de contenu peut souvent identifier les données requises en spécifiant le type de données).
Une autre configuration courante est un filtre qui décrit le schéma et le type de données. Par exemple, l'élément suivant définit Android pour obtenir des données vidéo (vidéo / _ * "à partir du réseau de composants (schéma =" http ") et exécuter une action.
python
<intent-filter>
<data android:scheme="http" android:mimeType="video/*"/>
...
</intent-filter>
Correspondance avec l'intention
Faire correspondre l'intention avec le filtre d'intention a pour fonction de rechercher le composant cible à démarrer et des informations sur certains composants du terminal. Par exemple, l'application d'accueil trouve toutes les activités qui ont un filtre d'intention qui spécifie l'action ACTION_MAIN </ font> et la catégorie VATEGORY_LUNCHER </ font>. Ensuite, entrez les données dans le lanceur d'applications (enregistrez l'application avec le composant qui peut être démarré dans le lanceur). La correspondance n'est établie que si l'action et la catégorie Intention réussissent le test de filtrage.
L'application que vous développez peut également correspondre aux intentions de la même manière que l'application domestique. PackageManager a une méthode query ... () et une méthode resolution ... (). La méthode query ... () fournit tous les composants qui peuvent recevoir l'intention, et la méthode resolver ... () détermine le meilleur composant pour répondre à l'intention. Par exemple, queryIntentActivities () fournit toutes les activités qui peuvent exécuter l'argument Intent et queryIntentService () fournit une liste de services similaires. Aucune des deux méthodes ne démarre un composant, elle fournit simplement une liste. Les récepteurs de diffusion ont une méthode similaire, queryBroadcastReceivers ().
Intention générale
Verrouillage d'alarme
calendrier
caméra
Application de carnet de contacts / contacts
Email
Stockage de fichiers
Action locale
carte
Clip musical
Nouvelle note
téléphone
Chercher
Réglage
Message texte
Navigateur Web
Vérification de l'intention avec le pont de débogage Android
Exemple de code (déréférencé ci-dessous)
Constitution
Project |
Faile |
Réglage |
Project01 |
Manifest.java |
enregistrer l'activité SubActivity <Intent-filter>L'ensemble |
|
MainActivity.java |
Écouteur de bouton |
|
activity_main.xml |
Placez deux boutons |
|
SubActivity.java |
|
|
activity_sub.xml |
TextView "Project01 SubActivity" |
Project02 |
Manifest.java |
activité Activité principale <Intent-filter>L'ensemble |
|
MainActivity.java |
|
|
activity_main.xml |
TextView "Project02 MainActivity" |
Project01
Manifest.java
Manifest.java
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
//■■■ Ajouter ↓ ■■■
<activity android:name=".SubActivity">
<intent-filter>
<action android:name="sub_activity"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</activity>
//■■■ Jusqu'ici ■■■
Disposition MainActivity (activity_main.xml)
activity_main.xml
<Button
android:id="@+id/button01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Button01"
/>
<Button
android:id="@+id/button02"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Button02"
/>
MainActivity.java
MainActivity.java
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button button01 = findViewById(R.id.button01);
Button button02 = findViewById(R.id.button02);
button01.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
Intent intent_sub = new Intent("sub_activity");
startActivity(intent_sub);
}
});
button02.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v){
Intent intent_pro02_main = new Intent("pro02_main_activity");
startActivity(intent_pro02_main);
}
});
}
Disposition SubActivity
activity_sub.xml
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="SubActivity in Project01"/>
SubActivity.java ne fait rien
Project02
Manifest.java
Manifest.java
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
//■■■ Ajouter ↓ ■■■
<intent-filter>
<action android:name="pro02_main_activity"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
//■■■ Jusqu'ici ■■■
</activity>
Présentation de l'activité principale
activity_main.xml
<TextView
android:text="MainActivity in Project02"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
/>
MainActivity.java ne fait rien
| | | |
|
| | |
|
| |
|