Discussion :

[DotNET74]

Bonjour,

J'ai une application qui doit se synchroniser avec une base de données SQL.

Pour réaliser la synchronisation, je passe par un Service Web vu que c'est plus simple que la réplication !!

Donc tout mon mécanisme de snychronisation fonctionne parfaitement.

Ce que je voudrais faire c'est déclencher cette synchronisation lors du branchement du Pocket PC sur son socle.

Merci

[freddyboy]

je ne sais pas sur quel materiel tu travail, mais une astuce est de detecter si la batterie est en charge ou pas. Normalement lorsque tu place le PDA sur le socle la batterie se charge (c'est comme cela que ca fonctionne avec les PDAs et socles que j'utilise).

Lorsque le PDA se trouve sur le socle et que la batterie se met en charge il y a un evenement de declencher, c'est à la reception de cet evenement que tu peux lancer ta synchronisation.

En esperant que cela te mets sur la voix ...

@+

[DotNET74]

super merci pour cette info importante.

Cependant, comment mon application doit se comporter.

Dois-je développer un Pocket Service Windows afin que ce dernier tourne tout le temps sur le Pocket ?

Merci encore

[freddyboy]

Je pense que le mieux pour cela est de te renseigner sur les APIs que fournit le constructeur. Personnellement je l'ai fait dernierement sur un PDA HHP et avec leurs APIs cela ma prit 1 heure de developpement.

Voila ce que j'ai fait sur HHP pour te donner une idée:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
using System;
using System.Threading;
using HHP.Device;
 
namespace testbattery
{
    /// <summary>
    /// Has the responsability to know if the pda is on the homebase or not
    /// </summary>
    public class PowerUtility : IDisposable
    {
        /// <summary>
        /// Power State
        /// </summary>
        public enum PowerState
        {
            PowerOn,
            PowerOff
        }
        /// <summary>
        /// Contains the current state
        /// </summary>
        private static PowerState myCurrentPowerState =
 PowerState.PowerOff;
        /// <summary>
        /// Store unique instance of NDPowerUtility
        /// </summary>
        private static NDPowerUtility oNDPowerUtility = null;
        /// <summary>
        /// Message window
        /// </summary>
        private UtilMessageWindow myUtilMessageWindow = null;
 
        /// <summary>
        /// Constructor
        /// </summary>
        private NDPowerUtility()
        {    
            myUtilMessageWindow = new UtilMessageWindow();
            myUtilMessageWindow.RegisterEventCallback(new
 HHP.Device.PDTEventList(true));
            myUtilMessageWindow.StartEventMonitor();
            myUtilMessageWindow.UtilEvent+=new UtilEventHandler
(OnUtilEvent);            
        }
        /// <summary>
        /// Singleton Pattern
        /// </summary>
        /// <returns>a NDPowerUtility Object</returns>
        public static NDPowerUtility GetInstance()
        {
            if (oNDPowerUtility == null)
            {
                // Only one thread can obtain a mutex
                Mutex aMutex = new Mutex();
                aMutex.WaitOne();
                oNDPowerUtility = new NDPowerUtility();
 
                if(HHP.Device.UtilMethods.GetACLineStatus())
                    myCurrentPowerState=PowerState.PowerOn;
                aMutex.Close();
            }
            return oNDPowerUtility;
        }
 
        /// <summary>
        /// Dispose
        /// </summary>
        public void Dispose()
        {
            myUtilMessageWindow.StopEventMonitor();
            myUtilMessageWindow.UtilEvent-=new UtilEventHandler
(OnUtilEvent);
            myUtilMessageWindow = null;
        }
 
        /// <summary>
        /// Util Event
        /// </summary>        
        private void OnUtilEvent(object sender, UtilEventArgs e)
        {            
            switch (e.UtilResults.type)
            {
                case HHP.Device.PDTEventType.EVENT_ACPOWER_ON:
                    myCurrentPowerState = PowerState.PowerOn;
                    break;
                case HHP.Device.PDTEventType.EVENT_ACPOWER_OFF:
                    myCurrentPowerState = PowerState.PowerOff;
                    break;
            }
        }
 
        /// <summary>
        /// Accessor to know the current power state
        /// </summary>
        public PowerState CurrentPowerState
        {
            get { return myCurrentPowerState; }
        }
    }
}

Il suffit de lancer cette classe au demarrage de l'application avec un PowerUtility.GetInstance();

Puis a chaque fois que tu place ou enleve le PDA de son socle l'événement OnUtilEvent est declenché et la variable myCurrentPowerState est mise à jour. C'est une boucle de message qui tourne en tache de fond. Pas besoin de thread ou de service, c'est tres simple.

Ensuite tu accede à la valeur avec l'accesseur.

@+

[DotNET74]

Super merci beaucoup