5.3 Support pour la manipulation de descriptions
6.1.2 Interpr´ etation de conditions de contexte
Les contraintes portant sur le contexte permettent de caract´eriser certains ´el´ements du contexte dans lequel une fonctionnalit´e peut fonctionner. Ces contraintes sont ex- prim´ees `a l’aide de conditions de contexte : ce sont des conditions qui impliquent des entit´es de l’environnement et qui doivent ˆetre v´erifi´ees pour autoriser l’utilisation du service. Les entit´es sur lesquelles portent ces conditions sont appel´ees param`etres de contexte. Certains param`etres peuvent ˆetre des variables, qui doivent alors ˆetre instan- ci´ees de mani`ere `a valider les conditions.
L’objectif du m´ecanisme d’interpr´etation de condition de contexte est de d´eter- miner si les conditions apparaissant sur les fonctionnalit´es (abstraites et r´eelles) sont v´erifi´ees dans la situation courante. La v´erification des conditions de contexte contenues dans les descriptions peut ˆetre r´ealis´ee `a l’aide d’un syst`eme de gestion de d’information de contexte (section 5.3.2).
Algorithme 3 : InterpretTypes Donn´ees :
une description de fonctionnalit´e abstraite (a, A) une description de fonctionnalit´e r´eelle (f , F )
R´esultat : un document τ d´ecrivant l’interpr´etation, un coˆut ∆τ
d´ebut 1 3db.load(A); 2 3db.load(F ); 3 ∆τ ← matchIndividual(a,f ); 4 τ ← 3db.createDoc(); 5 3db.addImport(τ , F ); 6 3db.addImport(τ , A); 7 si ∆τ= 0 alors 8
3db.write(τ , f , matching:isSimilarTo, a);
9
sinon si ∆τ≤ ∆maxalors 10
3db.write(τ , f , matching:isCloseTo, a);
11
sinon
12
3db.write(τ , f , matching:isFarFrom, a);
13 fin 14 setInterpretation(τ , ∆τ) 15 fin 16
a) El´´ements de description consid´er´es
L’expression de conditions sur le contexte n´ecessite l’introduction d’un mod`ele de description de ces conditions. La figure 6.4 repr´esente le mod`ele utilis´e. Ce mod`ele se base sur l’ontologie SWRL (Semantic Web Rule Language, (W3C, 2004b)), qui d´efinit des concepts permettant la descriptions de r`egles.
swrl:IndividualPropertyAtom
cond:ContextCondition
cond:ContextParameter
0..n 1 cond:hasConditionowl:Thing
cond:hasParameter 0..n 1Figure 6.4 – Ontologie des conditions sur le contexte
Cette ontologie d´efinit les deux concepts suivants :
cond:ContextParameter repr´esente un param`etre de contexte. N’importe quelle res- source peut ˆetre un param`etre de contexte (de type cond:ContextParameter). Un param`etre variable (c’est-`a-dire dont la valeur n’est pas d´efinie dans la descrip- tion) est `a la fois instance de cond:ContextParameter et de swrl:Variable.
cond:ContextCondition repr´esente une condition de contexte. Elle est d´efinie comme une sous-classe de swrl:IndividualPropertyAtom, qui repr´esente une clause SWRL portant sur la valeur d’une propri´et´e. Les arguments de la condition doivent ˆ
etre des instances de cond:ContextParameter (mais peuvent aussi ˆetre instances de swrl:Variable).
Exemple La figure 6.5 pr´esente une condition de contexte portant sur le cadre photo. Cette condition indique que l’utilisateur de la fonctionnalit´e fournie par le cadre photo doit percevoir ce cadre photo.
PFRAME
... pframe:msg_displayer cond:hasParameter pframe:user ; cond:hasParameter envThom:picture_frame ; cond:hasCondition pframe:condition . pframe:user a swrl:Variable ; a env:User . pframe:condition swrl:argument1 pframe:user ; swrl:argument2 envThom:picture_frame ; swrl:property env:perceives .Figure 6.5 – ´El´ements de description de conditions de contexte pour le cadre photo
La figure 6.6 pr´esente uniquement un param`etre de contexte portant sur la fonc- tionnalit´e abstraite de notification.
IRNOTIF
...
irnotif:notifier
cond:hasParameter envThom:Thom .
Figure 6.6 – ´El´ements de description de conditions de contexte pour la fonc- tionnalit´e abstraite de notification
b) Mod`ele de description de l’interpr´etation
Le r´esultat de l’interpr´etation de conditions de contexte est d´ecrit par
– les correspondances ´eventuelles entre les param`etres de contexte des descrip- tions de fonctionnalit´es abstraites et r´eelles, ainsi que les correspondances ´even- tuelles entre un param`etre de contexte variable et une entit´e (non-variable) de l’environnement. Ces correspondances sont exprim´ees `a l’aide de l’ontologie de correspondance pr´esent´ee dans la section pr´ec´edente (section 6.1.1, figure 6.2). – des informations sur la validit´e de la condition. Ces informations sont exprim´ees
`
cond:Condition
valid:verified xsd:boolean
valid:certainty xsd:integer
Figure 6.7 – Ontologie de v´erification des conditions de contexte
Cette ontologie d´efinit deux propri´et´es qui caract´erisent la v´erification d’une condition :
valid:verified indique si la condition est v´erifi´ee dans la situation courante.
valid:certainty indique le degr´e de certitude de la v´erification (entre 0 et 100). Dans certain cas, la condition est peut-ˆetre v´erifi´ee, mais la v´erification n’a pas pu ˆ
etre d´etermin´ee de mani`ere certaine.
Exemple La figure 6.8 pr´esente la description de la v´erification de la condition de contexte portant sur le cadre photo s’il est utilis´e comme dispositif de notification pour iRider. Deux informations y sont not´ees :
1. le param`etre variable pframe:user est identifi´e au param`etre constant envThom:Thom. 2. la condition (pframe:user ctxt:canPerceive envThom:picture frame), transform´ee
en (envThom:Thom ctxt:canPerceive envThom:picture frame) (apr`es instanciation de la variable pframe:user) est v´erifi´ee dans la situation courante.
CONTEXT[(pf,not)]
pframe:user matching:isSimilarTo envThom:Thom . pframe:condition valid:verified TRUE ; valid:certainty 100 .Figure 6.8 – Exemple de description de la v´erification d’une condition
c) Algorithme d’interpr´etation
L’algorithme d’interpr´etation InterpretContextCondition (page 117) ´evalue une condition de contexte en trois ´etapes :
1. identification de la correspondance des param`etres de contexte dans les descrip- tions de fonctionnalit´e abstraite et de fonctionnalit´e r´eelle.
2. instanciation des param`etres variables pour lesquels il existe une correspondance avec un param`etre fix´e.
3. ´evaluation de la validit´e de la condition.
4. ´ecriture des r´esultats dans un document d’interpr´etation
Tout d’abord, l’´etape d’identification de la correspondance utilise une fonction mat- chIndividualSet(), qui permet de d´eterminer des correspondances entre deux en- sembles de ressources similaires. Ici, cette fonction est utilis´ee avec les ensembles de param`etres de contexte d´efinis pour la fonctionnalit´e abstraite et pour la fonctionna- lit´e r´eelle. La fonction matchIndividualSet() utilise la fonction matchIndividual() d´efinie pr´ec´edemment (section 6.1.1) pour d´eterminer les correspondances entre les
Algorithme 4 : InterpretContextCondition Donn´ees :
une description de fonctionnalit´e abstraite (a, A) une description de fonctionnalit´e r´eelle (f , F )
R´esultat : un document τ d´ecrivant l’interpr´etation, un coˆut ∆τ
d´ebut 1 3db.load(A); 2 3db.load(F ); 3 Pa ← 3db.selectAll(a, cond:hasParameter, ?p); 4 Pf ← 3db.selectAll(f , cond:hasParameter, ?p); 5 M ← matchIndividualSet(Pa, Pf); 6 c ← 3db.select(f , cond:hasCondition, ?c); 7 s ← 3db.select(c, swrl:argument1, ?s); 8 p ← 3db.select(c, swrl:property, ?p); 9
o ← 3db.select(c, swrl:argument2, ?o);
10 s0← instanciateVariableParameter(s,M ); 11 o0← instanciateVariableParameter(o,M ); 12 query ← expressSPARQLQuery(s0, p, o0); 13
Enregistrement de la requˆete query;
14
tant que vrai faire
15
R ← r´eception d’une r´eponse `a la requˆete query;
16 τ ← 3db.createDoc(); 17 3db.addImport(τ , F ); 18 3db.addImport(τ , A); 19 si R = ∅ alors 20 ∆τ = 1000; 21
3db.write(τ , c, valid:Verified, false);
22
sinon
23
∆τ = 0; 24
3db.write(τ , c, valid:Verified, true);
25 writeParameterMatch(τ , M , R); 26 fin 27 setInterpretation(τ , ∆τ); 28 fin 29 fin 30
Fonction matchIndividualSet(A: ensemble de ressources, F : ensemble de ressources) → M atches : ensemble de correspondances
Entr´ees :
un ensemble de ressources A = {a1, . . . , an} issues d’une description de fonctionnalit´e abstraite,
un ensemble de ressources F = {f1, . . . , fm} issues d’une description de fonctionnalit´e r´eelle
Sorties : un ensemble de correspondances M atches = {(a, f , cost)}, o`u cost est le degr´e de correspondance entre les ressources a et f. d´ebut
1
pour tous les a ∈ A faire
2
costa ← 1000; 3
matcha← null; 4
pour tous les f ∈ F faire
5
costa,f ← matchIndividual(a, f ); 6
si costa,f < costa alors 7
costa ← costa,f; 8 matcha← f ; 9 fin 10 fin 11
Ajouter (a, matcha, costa) `a M atches; 12 fin 13 retourner M atches 14 fin 15
´el´ements de chacun des ensembles. Elle met ainsi en correspondance les couples pour lesquels le degr´e de correspondance est le plus faible. Ici, cette fonction est utilis´e pour d´eterminer si des param`etres de contexte de la fonctionnalit´e abstraite correspondent aux param`etres de contexte de la fonctionnalit´e r´eelle. En particulier, lorsque les condi- tions de contexte comprennent des variables, on peut instancier ces variables avec les param`etres de contexte d´efinis dans la description de fonctionnalit´e abstraite.
L’algorithme effectue ensuite l’instanciation des param`etres variables `a l’aide une fonction instanciateVariableParameter(). Dans l’expression de la condition, le sujet s et l’objet o peuvent ˆetre de type swrl:Variable. Dans ce cas o`u l’un de ces param`etres de contexte est une variable, la fonction instanciateVariableParameter() exploite l’ensemble de correspondances fournies par la fonction matchIndividualSet() pour tenter de remplacer cette variable par un param`etre de contexte non variable.
`
A partir des informations contenues dans la description, l’algorithme construit ensuite une requˆete SPARQL. Cette requˆete est destin´ee `a ˆetre prise en charge par le registre d’int´erˆets sur le contexte, dont le fonctionnement est d´etaill´e dans la section 5.3.2. La fonction expressSPARQLQuery() indique comment une requˆete est formul´ee `a partir du triplet (s0 p o0). Plusieurs cas peuvent se pr´esenter :
– si aucun param`etre n’est une variable, la requˆete SPARQL est de la forme ASK { s0 p o0 }.
– si le sujet est une variable, la requˆete SPARQL est de la forme SELECT ?s WHERE { ?s p o0 }.
– si l’objet est une variable, la requˆete SPARQL est de la forme SELECT ?o WHERE { s0 p ?o }.
– si le sujet et l’objet sont des variables, la requˆete SPARQL est de la forme SELECT ?s, ?o WHERE { ?s p ?o }.
La requˆete est ensuite soumise au registre d’int´erˆets sur le contexte. La r´eponse `a cette requˆete est trait´ee en boucle : `a chaque modification du contexte pertinent, le registre d’int´erˆets sur le contexte fournit une nouvelle r´eponse. La r´eponse R du registre d’int´erˆets sur le contexte est un ensemble de r´esultats (instanciation des variables). Pour simplifier, on ne consid`ere pas ici d’´evaluation de la confiance des r´esultats.
La derni`ere ´etape consiste `a ´ecrire les r´esultats dans un document d’interpr´etation. Dans le cas o`u le r´esultat R est vide, on consid`ere que la condition n’est pas v´erifi´ee et le coˆut est ´elev´e. Dans le cas contraire, on consid`ere que la condition est v´erifi´ee, et on indique dans le document les valeurs appropri´ees pour les param`etres variables. La fonction writeParameterMatch() permet d’´ecrire les correspondance entre les pa- ram`etres dans le document τ , en utilisant `a la fois les correspondances obtenues par la fonction matchIndividualSet() et les r´esultats de la requˆete.