Composant non visuel (PullSDK-ZkTeko)

**Ouail1825** · 05/06/2016, 00h36

Salut et bonjour ..
pour un mini projet de connexion d'une C3 accesspanel control de ZkTeko, dont cette dernière est livrée avec des sdk nommées PullSDK, composées de 5 DLL
Nom : PullSdk.png
Affichages : 2260
Taille : 73,5 Ko

Nom : PullSdk.png
Affichages : 2260
Taille : 73,5 Ko

les démos fournis avec cette panel sont faites avec le C#
cette Panel fonctionne avec 16 functions, dont j'ai pu les importer à mon mini-projet, où j'ai pu me connécter facilement à l'appareil.
le problème consiste à pouvoir se connécter à plusieurs appareils simultanément, où je me suis confronté à plusieurs conflits entre eux.
donc je pensais, peut-être pouvoir réaliser un composant non visuel, dérivé d'un TComponent, pouvant remédier cette situation.
j'ai cherché sur le net mais sans aucune solution.
*********************************************
les 16 function comme j'ai interprété sont:

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
    function Connect(Parameters: PChar): THandle; StdCall; external 'plcommpro.dll';
    Procedure Disconnect (HandleDLL:THandle);StdCall; external 'plcommpro.dll';
    function PullLastError():Integer;StdCall; external 'plcommpro.dll';
    function SetDeviceParam (Han : THandle; ItemValues:PChar):Integer;StdCall; external 'plcommpro.dll';
    function GetDeviceParam (Han : THandle; Var Buffer:Byte; BufferSize: Integer;
                         ItemValues:PChar):Integer;StdCall; external 'plcommpro.dll';
    function ControlDevice  (Han : THandle; operationid: Integer; param1,
                             param2, param3, param4 : Integer; options: PChar): Integer; StdCall; external 'plcommpro.dll';
    function SetDeviceData  (Han : THandle; tablename, data, options:PChar): Integer;StdCall; external 'plcommpro.dll';
    function GetDeviceData  (Han : THandle; buffer:Byte; buffersize:Integer;
                             tablename, filename, filter,Option :PChar):Integer;StdCall; external 'plcommpro.dll';
    function GetDeviceDataCount  (Han : THandle; tablename,filter,options: PChar ): Integer;StdCall; external 'plcommpro.dll';
    function DeleteDeviceData    (Han : THandle; tablename, data, options:PChar): Integer;StdCall; external 'plcommpro.dll';
    function GetRTLog            (Han : THandle; Var buffer; buffersize:Integer): Integer;StdCall; external 'plcommpro.dll';
    function SearchDevice        (commtype, address:PChar; buffer: Byte): Integer;StdCall; external 'plcommpro.dll';
    function ModifyIPAddress     (commtype, address, buffer: PChar): Integer;StdCall; external 'plcommpro.dll';
 
    function SetDeviceFileData   (Han : THandle; filename:PChar; Var buffer;
                               buffersize:Integer; options:PChar): Integer;StdCall; external 'plcommpro.dll';
    function GetDeviceFileData   (Han : THandle; Var buffer; buffersize:integer;
                               filename, options:PChar):integer;StdCall; external 'plcommpro.dll';
    function ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;StdCall; external 'plcommpro.dll';

le lien pour les SDK et la documentation de la DLL est: https://drive.google.com/open?id=0Bz...UNDRGtmYWpKNUU

toutes les functions interprétés, sont testées avec succès, je peux même fournir des modéls de teste.
merci d'avance..

**Ouail1825** · 05/06/2016, 00h41

un ex d'utilisation de la fonction (Connect)

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
procedure TForm1.BtnConnectClick(Sender: TObject);
var str : PChar;
    Ret,I : Integer;
    Adr : String;
begin 
DataModule2.TMachines.First;
for I := 0 to DataModule2.TMachines.RecordCount -1 do
  Begin
   Memo2.Lines.Add('Connexion à: '+DataModule2.TMachinesMachineAlias.Value+'...');
   Adr := 'protocole:TCP,ipadresse:'+(DataModule2.TMachinesIP.Value)+',port=4370,timeout=4000,password=';
   str := PChar(Adr);
   Device [I] := Connect (Str);
   if Device [I] <> 0 then Memo2.Lines.Add('Connexion réussit !')
    Else
     Begin
      ret := pulllasterror();
      Memo2.Lines.Add('Non Connécté code erreur : '+ret.ToString());
     End;
   DataModule2.TMachines.Next;
  End;
end;

**ShaiLeTroll** · 06/06/2016, 10h35

Je ne vois pas ce qu'apporterait d'hériter de TComponent !
Tu peux hériter tout simplement de TObject

Vu ton projet très lié à ces DLL, je ne vois pas en quoi on peut t'aider !
Ce n'est qu'un simple travail d'encapsulation de DLL sous la forme d'une classe ou plusieurs classes.
Propose nous un code POO et l'on t'aidera si tu as vraiment des difficultés liés au langage .

J'ai déjà fait ce travail pour utiliser plusieurs marques d'appareil chacun avec des bibliothèques ou protocoles différents (SDK DLL, ActiveX, HTTP, ...)
J'avais fait une couche exposant un Hardware générique et un système d'interface avec Supports pour indiquer qu'un Hardware gère telle ou telle fonctionnalité.

**Ouail1825** · 09/06/2016, 19h23

Salut ShaiLeTroll , merci de répondre, et excuse d'avoir pris tou ce temps ...

donc, mon problème est que j'ai sept (07) Access Control Panels C3-200 de ZkTeco, dont chacune contrôle deux portes ou deux accès, si je travail avec un seul Panel, je n'ai aucun problème durant la communication ou le téléchargement des données, mais si je travail sur plusieurs panels j'arrive pas à les distinguer ou les identifier les unes des autres.
Exemple: durant l'envoi de données je ne sais pas si je suis connecté au panel1 ou 2 ou 3 ....

c'est pour ça, je voulais savoir si c'était possible d’écrire un composant qui encapsule toutes les functions supra-citées, et servant à identifier ces appareils, où à chaque fois que je connecte un panel, l'application crée dynamiquement le composant.

j'espere que j'étais claire, merci.

**ShaiLeTroll** · 10/06/2016, 09h12

Tout est possible, il faut juste se lancer et le faire !
Je ne comprends pas ce qui te bloques
Tu dois juste bien gérer tes Handle de périphérique, la clé est là, tout est dans ces handles.

C'est du contrôle d'accès, je connais, je me suis plutôt occupé de la vidéo-surveillance, comme toi, j'avais plusieurs caméras/enregistreur/serveur, avec des marques différents donc protocoles différents,
je devais afficher la vidéo d'une caméra comme si c'était une sorte de vidéo-phone mais aussi lors d'une rupture de contact indiquant une effraction ou alors de mouvement durant une plage horaire où personne ne devrait être là ...
J'avais aussi développer un moniteur vidéo pouvant afficher jusqu'à 32 caméras et avec des dispositions cycliques, comme toi, il y avait une gestion fine des Handles ou des Identifiants propre à chaque SDK, tu as la chance pour le moment tu n'en as qu'un seul.

Avant de commencer la notion de classe, tu dois déjà impérativement pour bien séparé tes périphériques, si tu n'y arrives pas en procédural, tu n'y arriveras pas mieux en Objet
ton problème concerne un manque de maîtrise du SDK, ce n'est pas un problème lié à Delphi
Une fois que tu auras maitrisé cette gestion de handle (un simple tableau de record à mon avis peut suffir), tu pourras passer à un code POO

As-tu commencé ta classe, as-tu des questions précises sur la syntaxe ?
as-tu des difficultés avec la POO ?

Mon code est beaucoup trop long, mais voici rien que la partie déclaration de la classe abstraite, un périphérique peu importe si c'est une Caméra, un Enregistreur, un Lecteur (125K, Mifare, Desfire, ...), un contact de Porte, un contact d'intrusion ... tout est un périphérique
La structure c'est un EXE, des DLL internes qui fournisse l'interface ISliteHardwareEntity, grace à Supports cela permet de savoir ce que peut faire le périphérique
Ces DLL internes sont encapsulation au SDK externe, c'est ce que veux faire !

ça c'est côté EXE, la classe abstraite donnant un point d'accès aux différentes DLL internes

Code c++ :

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
 
//---------------------------------------------------------------------------
#ifndef SliteHardwareAbstractWrapperClassesH
#define SliteHardwareAbstractWrapperClassesH
//---------------------------------------------------------------------------
#include <vcl.h>
#include <SyncObjs.hpp>
//---------------------------------------------------------------------------
#include <map>
//---------------------------------------------------------------------------
#include "SupervisionGenericClasses.h"
#include "SupervisionORClasses.h"
//---------------------------------------------------------------------------
#include "SliteHardwareAbstractInterfaces.h"
#include "SliteHardwareAbstractTypes.h"
//---------------------------------------------------------------------------
 
/* Forward Declarations */
class RTL_DELPHICLASS TSliteHardwareProviderManager;
class RTL_DELPHICLASS TSliteHardwareProviderManagerFactory;
class RTL_DELPHICLASS TSliteHardwareProviderList;
class RTL_DELPHICLASS TSliteHardwareProvider;
class RTL_DELPHICLASS TSliteHardwareProviderModelList;
class RTL_DELPHICLASS TSliteHardwareProviderModel;
class RTL_DELPHICLASS TSliteHardwareProviderEntity;
class RTL_DELPHICLASS TSliteHardwareProviderConfigurator;
class RTL_DELPHICLASS TSliteHardwareProviderAbstractPersistentObject;
 
//---------------------------------------------------------------------------
typedef void __fastcall (__closure *TSliteHardwareProviderInitializeStateEvent)(TSliteHardwareProviderManager * Sender, ISliteHardwareProvider* AProviderIntf, TSliteHardwareSystemState AState, TSliteHardwareProviderEventInitializeStateData *AStateData);
 
typedef void __fastcall (__closure *TSliteHardwareProviderEntityChangeStateEvent)(TSliteHardwareProviderManager * Sender, ISliteHardwareEntity* AEntityIntf, TSliteHardwareEntityState AState, void *AStateIntf, void *AStateData, int AStateDataLen);
typedef void __fastcall (__closure *TSliteHardwareProviderEntityErrorEvent)(TSliteHardwareProviderManager * Sender, ISliteHardwareEntity* AEntityIntf, TSliteHardwareEntityError AError, void *AErrorIntf, void *AErrorData, int AErrorDataLen);
 
typedef void __fastcall (__closure *TSliteHardwareProviderPurposeEntityChangeStateEvent)(TSliteHardwareProviderManager * Sender, ISliteHardwareEntity* AEntityIntf, int AState, void *AStateIntf, void *AStateData, int AStateDataLen);
typedef void __fastcall (__closure *TSliteHardwareProviderPurposeEntityErrorEvent)(TSliteHardwareProviderManager * Sender, ISliteHardwareEntity* AEntityIntf, int AError, void *AErrorIntf, void *AErrorData, int AErrorDataLen);
 
typedef void __fastcall (__closure *TSliteHardwareProviderEntityBeforeReleaseEvent)(TSliteHardwareProviderEntity * Sender, ISliteHardwareModel* AModelIntf, ISliteHardwareEntity* AEntityIntf);
 
//---------------------------------------------------------------------------
//                           ESliteHardwareError                            -
//---------------------------------------------------------------------------
class ESliteHardwareError : public Sysutils::Exception
{
  typedef Sysutils::Exception inherited;
 
public:
  /*constructor*/inline __fastcall ESliteHardwareError(const String Msg) : inherited(Msg) { }
  /*constructor*/inline __fastcall ESliteHardwareError(const String Msg, System::TVarRec const * Args, const int Args_Size) : inherited(Msg, Args, Args_Size) { }
};
 
//---------------------------------------------------------------------------
//                     ESliteHardwareProviderManagerError                   -
//---------------------------------------------------------------------------
class ESliteHardwareProviderManagerError : public ESliteHardwareError
{
  typedef ESliteHardwareError inherited;
 
public:
  /*constructor*/inline __fastcall ESliteHardwareProviderManagerError(const String Msg) : inherited(Msg) { }
  /*constructor*/inline __fastcall ESliteHardwareProviderManagerError(const String Msg, System::TVarRec const * Args, const int Args_Size) : inherited(Msg, Args, Args_Size) { }
  /*constructor*/inline __fastcall ESliteHardwareProviderManagerError(const String Fmt, const String Msg, const TFileName ADLLName) : inherited(Fmt, ARRAYOFCONST((Msg, ADLLName))) { }
};
 
//---------------------------------------------------------------------------
//                       TSliteHardwareProviderManager                      -
//---------------------------------------------------------------------------
typedef TMetaClass* TSliteHardwareProviderManagerClass;
typedef TSliteHardwareProviderManager* (__stdcall *TSliteHardwareProviderManagerFactoryConstructorProcedure)(void);
//---------------------------------------------------------------------------
#pragma option push -w-diu // W8130 L'interface ne dérive pas de IUnknown.
class TSliteHardwareProviderManager : public TObject, public ISliteHardwareProviderEvents
{
#pragma option pop
public:
  // Types Publiques
  typedef String TDLLName;
  typedef TDLLName TDLLPrefixName;
 
private:
  // Membres Privés
  TFileName FDLLDirectory;
  TFileName FOptionsIniFileName;
 
  WideString FDefaultLogin;
  WideString FDefaultPassword;
 
  // Membres Privés (DLL Wrapper)
  typedef struct
  {
    bool IsValidDLL;
    bool LoadingDLL;
    bool FreeingDLL;
    HMODULE DLLHandle;
    wchar_t DLLName[MAX_PATH];
    DWORD LoadInThreadID;
    DWORD DLLWinLastError; // Erreur Windows !
    ISliteHardwareProvider* HardwareProviderIntf;
    LPFN_GetSliteHardwareLastError GetSliteHardwareLastError;
    TSliteHardwareInterfaceErrorType LastInterfaceError;
    TSliteHardwareProviderModelList* ModelList;
    struct
    {
      bool EntityChangeStateInitialized;
      bool EntityErrorInitialized;
    } EventHandler;
  } TProviderDLLWrapperData;
  typedef std::map<TDLLName, TProviderDLLWrapperData*> TProviderDLLWrapperDataMap;
  TProviderDLLWrapperDataMap FDataByDLLName;
  TCriticalSection* FDataByDLLNameThreadLock;
  bool FDestroying;
 
  TSliteHardwareProviderInitializeStateEvent FOnInitialize;
  TSliteHardwareProviderEntityChangeStateEvent FOnEntityChangeState;
  TSliteHardwareProviderEntityErrorEvent FOnEntityError;
  TSliteHardwareProviderPurposeEntityChangeStateEvent FOnPurposeEntityChangeState;
  TSliteHardwareProviderPurposeEntityErrorEvent FOnPurposeEntityError;
 
  // Méthodes Privées (DLL Load)
  bool LoadDLL(const TDLLName ANewDLLName, TProviderDLLWrapperData* DLLData);
  bool FreeDLL(TProviderDLLWrapperData* DLLData, DWORD AWinLastError = 0, TSliteHardwareInterfaceErrorType AIntfLastError = shwieNoError);
  TProviderDLLWrapperData* GetDataByDLLName(const TDLLName ANewDLLName);
  TProviderDLLWrapperData* GetDataByProvider(TSliteHardwareProvider *AProvider);
 
  // Accesseurs
  TFileName __fastcall GetDLLDirectory(); // throw(ESliteHardwareProviderManagerError)
  TFileName __fastcall GetOptionsIniFileName();
 
protected:
  // Constructeurs Protégés (Masqués)
  /*constructor*/__fastcall TSliteHardwareProviderManager();
 
  // Méthodes Protégées (Divers)
  __classmethod virtual TUtilSytel* GetUtilSytel();
 
  // Méthodes Protégées (Multiton - Instance Registry)
  static TSliteHardwareProviderManager* GetInstance(TSliteHardwareProviderManagerClass AClass);
  static bool RegisterClass(TSliteHardwareProviderManagerClass AClass, TSliteHardwareProviderManagerFactoryConstructorProcedure AConstructorFunction);
 
  // Méthodes dont je recommande l'implémentation (en C++ le "static virtual pure" n'existe pas contrairement à Delphi et son "class abstract")
  //static void RegisterMe();
  //static TSliteHardwareProviderManager* __stdcall CreateInstance(TSliteHardwareProviderManagerClass AClass);
 
  // Méthodes Abstraites Protégées devant être rédéfinies
  /*abstract*/virtual TDLLPrefixName GetDLLPrefixFileName() = 0;
  /*abstract*/virtual bool AcceptProviderDLL(TSliteHardwareProvider *AProvider) = 0;
 
  // Méthodes Protégées pouvant être rédéfinies
  virtual int FillProviderListFromDB(TSliteHardwareProviderList* AList);
  virtual int FillProviderListFromFiles(TSliteHardwareProviderList* AList); // throw(ESliteHardwareProviderManagerError)
  virtual bool AllowFillingProviderListFromFiles();
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteHardwareProviderManager();
 
  // Méthodes Publiques
  int FillProviderList(TSliteHardwareProviderList* AList); // throw(ESliteHardwareProviderManagerError)
  int ReleaseAllProviderInterfaces();
 
  bool IsValidDLL(TSliteHardwareProvider *AProvider);
  ISliteHardwareProvider* GetProviderInterface(TSliteHardwareProvider *AProvider);
  TSliteHardwareInterfaceErrorType GetLastInterfaceError(TSliteHardwareProvider *AProvider);
  TSliteHardwareProviderModelList* __fastcall TSliteHardwareProviderManager::GetModelList(TSliteHardwareProvider *AProvider);
 
  // ....
 
  // Implementations of Interface Event Handler Methods
  virtual void __stdcall EventHandlerEntityChangeState(ISliteHardwareProvider* AProviderIntf, ISliteHardwareEntity* AEntityIntf, TSliteHardwareEntityStateValueType AStateType, int AState, void *AStateIntf, void *AStateData, int AStateDataLen);
  virtual void __stdcall EventHandlerEntityError(ISliteHardwareProvider* AProviderIntf, ISliteHardwareEntity* AEntityIntf, TSliteHardwareEntityErrorValueType AErrorType, int AError, void *AErrorIntf, void *AErrorData, int AErrorDataLen);
 
  // Propriétés Publiques
  __property TFileName DLLDirectory = {read=GetDLLDirectory, write=FDLLDirectory};
  __property TFileName OptionsIniFileName = {read=GetOptionsIniFileName, write=FOptionsIniFileName}; // Chemin Complet pour TUtilSytel::LitChaineIni
 
  __property WideString DefaultLogin = {read=FDefaultLogin, write=FDefaultLogin};
  __property WideString DefaultPassword = {read=FDefaultPassword, write=FDefaultPassword};
 
  // Evènements Publiques
  __property TSliteHardwareProviderInitializeStateEvent OnInitialize = {read=FOnInitialize, write=FOnInitialize};
  __property TSliteHardwareProviderEntityChangeStateEvent OnEntityChangeState = {read=FOnEntityChangeState, write=FOnEntityChangeState};
  __property TSliteHardwareProviderEntityErrorEvent OnEntityError = {read=FOnEntityError, write=FOnEntityError};
  __property TSliteHardwareProviderPurposeEntityChangeStateEvent OnPurposeEntityChangeState = {read=FOnPurposeEntityChangeState, write=FOnPurposeEntityChangeState};
  __property TSliteHardwareProviderPurposeEntityErrorEvent OnPurposeEntityError = {read=FOnPurposeEntityError, write=FOnPurposeEntityError};
};
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//                   TSliteHardwareProviderManagerFactory                   -
//---------------------------------------------------------------------------
class TSliteHardwareProviderManagerFactory : public TObject
{
private:
  // Membres Privés (Singleton)
  static TSliteHardwareProviderManagerFactory *FSingletonInstance;
  static DWORD FFirstThreadID;
 
  // Membres Privés (Class Registry \ Factory)
  typedef void* TSliteHardwareProviderManagerConstructorMapItem; // Evite une "F1004 Erreur du compilateur interne at 0x........ with base 0x5df0000" si l'on utilise directement TSliteHardwareProviderManagerFactoryConstructorProcedure
  typedef std::map<TSliteHardwareProviderManagerClass, TSliteHardwareProviderManagerConstructorMapItem> TSliteHardwareProviderManagerConstructorMap;
  TSliteHardwareProviderManagerConstructorMap FFactoryConstructors; // Methods Registry
 
  // Membres Privés (Multiton - Instance Registry)
  typedef TSliteGenericObjectList<TSliteHardwareProviderManager> TSliteHardwareProviderManagerInstanceList;
  TSliteHardwareProviderManagerInstanceList* FMultitonInstances;
  TCriticalSection* FMultitonLockThread;
 
  // Constructeurs Privés (Masqués)
  /*constructor*/__fastcall TSliteHardwareProviderManagerFactory();
 
  // Méthodes Privées (Factory \ Multiton - Instance Registry)
  TSliteHardwareProviderManager* FindMultiton(TSliteHardwareProviderManagerClass AClass);
  TSliteHardwareProviderManagerFactoryConstructorProcedure FindConstructor(TSliteHardwareProviderManagerClass AClass);
  TSliteHardwareProviderManager* CreateMultiton(TSliteHardwareProviderManagerClass AClass, TSliteHardwareProviderManagerFactoryConstructorProcedure AConstructorFunction);
 
  // Méthodes Privées (ThreadSafe Multiton - Instance Registry)
  void InitThreadSynchronization();
  void DoneThreadSynchronization();
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteHardwareProviderManagerFactory();
 
  // Méthodes Publiques (Singleton)
  static TSliteHardwareProviderManagerFactory* GetInstance();
  static void ReleaseInstance();
  static bool RegisterFirstThread(DWORD AThreadID);
 
  // Méthodes Publiques (Class Registry)
  bool RegisterClass(TSliteHardwareProviderManagerClass AClass, TSliteHardwareProviderManagerFactoryConstructorProcedure AConstructorFunction);
 
  // Méthodes Publiques (Multiton - Instance Registry)
  TSliteHardwareProviderManager* GetRegisteredInstance(TSliteHardwareProviderManagerClass AClass);
};
//---------------------------------------------------------------------------
TSliteHardwareProviderManagerFactory * TSliteHardwareProviderManagerFactory::FSingletonInstance = NULL;
DWORD TSliteHardwareProviderManagerFactory::FFirstThreadID = 0;
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//                        TSliteHardwareProviderList                        -
//                  TSliteHardwareProviderListBaseTemplate                  -
//---------------------------------------------------------------------------
typedef TSliteGenericObjectList<TSliteHardwareProvider> TSliteHardwareProviderListBaseTemplate;
class TSliteHardwareProviderList : public TSliteHardwareProviderListBaseTemplate
{
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteHardwareProviderList(bool AOwnsObjects) : TSliteHardwareProviderListBaseTemplate(AOwnsObjects) {};
};
 
//---------------------------------------------------------------------------
//                         ESliteHardwareProviderError                      -
//---------------------------------------------------------------------------
class ESliteHardwareProviderError : public ESliteHardwareError
{
  typedef ESliteHardwareError inherited;
 
public:
  /*constructor*/inline __fastcall ESliteHardwareProviderError(const String Msg) : inherited(Msg) { }
};
 
//---------------------------------------------------------------------------
//                         ESliteHardwarePurposeError                       -
//---------------------------------------------------------------------------
class ESliteHardwarePurposeError : public ESliteHardwareError
{
  typedef ESliteHardwareError inherited;
 
public:
  /*constructor*/inline __fastcall ESliteHardwarePurposeError(const String Msg) : inherited(Msg) { }
  /*constructor*/inline __fastcall ESliteHardwarePurposeError(const String Msg, System::TVarRec const * Args, const int Args_Size) : inherited(Msg, Args, Args_Size) { }
};
 
//---------------------------------------------------------------------------
//                           TSliteHardwareProvider                         -
//---------------------------------------------------------------------------
class TSliteHardwareProvider : public TSliteORPersistent
{
  typedef TSliteORPersistent inherited;
 
private:
  // Membres Privés
  TSliteHardwareProviderManager* FManager;
 
  // Membres Privés (propriétés publiées)
  TMemberString FDLLName;
  TMemberString FProviderName;
  TMemberString FProviderCompanyName;
 
protected:
  // Constructeurs Protégés
  void InternalCreate(TSliteHardwareProviderManager* AManager); // all constructor must call InternalCreate
 
  // Accesseurs (propriétés publiées)
  // Do Not use reference parameter for published property setter
  TPropertyString __fastcall GetDLLName();
  void __fastcall SetDLLName(const TPropertyString Value);
  TPropertyString __fastcall GetProviderName();
  TPropertyString __fastcall GetProviderCompanyName();
 
  // Accesseurs (propriétés publiques)
  bool __fastcall GetIsValidDLL();
  ISliteHardwareProviderCapabilitiesDelphiInterface __fastcall GetCapabilities();
  int __fastcall GetModelCount(); // throw(ESliteHardwareProviderManagerError)
  TSliteHardwareProviderModel* __fastcall GetModels(int Index); // throw(ESliteHardwareProviderManagerError)
  TSliteHardwareProviderModel* __fastcall GetModelByCode(const String Code); // throw(ESliteHardwareProviderManagerError)
 
  // Accesseurs (propriétés protégées)
  TSliteHardwareProviderModelList* __fastcall GetModelList(); // throw(ESliteHardwareProviderManagerError)
 
  // Accesseurs (propriétés bloquées)
  /*override*/virtual void __fastcall SetDataSource(TDataSource* Value); // throw(ESliteHardwareProviderError)
 
  // Propriétés Protégées
  __property TSliteHardwareProviderModelList* ModelList = {read=GetModelList};
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteHardwareProvider(TSliteHardwareProviderManager* AManager);
  /*constructor*/__fastcall TSliteHardwareProvider(TSliteHardwareProviderManager* AManager, const TSliteHardwareProviderManager::TDLLName ADLLName);
  /*constructor*/__fastcall TSliteHardwareProvider(TSliteHardwareProviderManager* AManager, TDataSet* ADataSet);
 
  // Méthodes Publiques
  bool IsSame(TSliteHardwareProvider* Value);
  /*override*/virtual bool Save();
  int FillModelList(TStrings *AList);
  int IndexOfInModelListByCode(TStrings *AList, const String AModelCode);
  TSliteHardwareInterfaceErrorType GetLastInterfaceError();
 
  TSliteHardwareProvider* Clone();
 
  // Méthodes Redéfinies
  /*override*/__classmethod virtual bool IsRecordable() {return true;}
  /*override*/__classmethod virtual bool IsRelation() {return false;}
 
  // Propriétés Publiques
  __property bool IsValidDLL = {read=GetIsValidDLL};
  __property ISliteHardwareProviderCapabilitiesDelphiInterface Capabilities = {read=GetCapabilities};
  __property int ModelCount = {read=GetModelCount};
  __property TSliteHardwareProviderModel* Models[int Index] = {read=GetModels};
  __property TSliteHardwareProviderModel* ModelByCode[const String Code] = {read=GetModelByCode};
 
__published:
  // Propriétés Publiées
  __property PrimaryID; // Augmentation de Visibilité
  __property TPropertyString DLLName = {read=GetDLLName, write=SetDLLName};
  __property TPropertyString ProviderName = {read=GetProviderName}; // La Valeur en DB n'est là qu'a titre informatif (pour faciliter une maintenance !)
  __property TPropertyString ProviderCompanyName = {read=GetProviderCompanyName}; // La Valeur en DB n'est là qu'a titre informatif (pour faciliter une maintenance !)
 
public:
  static const TPropertyName PROP_NAME_HARDWARE_PROVIDER_NAME;
  static const TPropertyName PROP_NAME_HARDWARE_PROVIDER_DLL_NAME;
  static const TPropertyName PROP_NAME_HARDWARE_PROVIDER_COMPANY_NAME;
  static const TUtilSytelSQLProcName SQL_SELECT_GET_HARDWARE_PROVIDER_BY_DLL_NAME;
  static const TUtilSytelSQLProcName SQL_SELECT_GET_HARDWARE_PROVIDERS_WHERE_PREFIX_IS;
};
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//                      TSliteHardwareProviderModelList                     -
//                TSliteHardwareProviderModelListBaseTemplate               -
//---------------------------------------------------------------------------
typedef TSliteGenericObjectList<TSliteHardwareProviderModel> TSliteHardwareProviderModelListBaseTemplate;
class TSliteHardwareProviderModelList : public TSliteHardwareProviderModelListBaseTemplate
{
private:
  // Membres Privés
  ISliteHardwareProvider* FHardwareProviderIntf;
 
protected:
  // Accesseurs
  TSliteHardwareProviderModel* __fastcall GetModelByCode(const String Code);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteHardwareProviderModelList(ISliteHardwareProvider* AHardwareProviderIntf);
 
  // Propriétés Publiques
  __property TSliteHardwareProviderModel* ModelByCode[const String Code] = {read=GetModelByCode};
};
 
//---------------------------------------------------------------------------
//                        TSliteHardwareProviderModel                       -
//---------------------------------------------------------------------------
class TSliteHardwareProviderModel : public TObject
{
  friend class TSliteHardwareProviderModelList;
  friend class TSliteHardwareProviderEntity;
 
private:
  // Membres Privés
  ISliteHardwareModel* FHardwareModelIntf;
 
  // Accesseurs
  String __fastcall GetModelCode() {return FHardwareModelIntf->ModelCode;}
  String __fastcall GetModelName() {return FHardwareModelIntf->ModelName;}
 
protected:
  // Constructeurs Protégés (Masqués)
  /*constructor*/__fastcall TSliteHardwareProviderModel(ISliteHardwareModel* AHardwareModelIntf);
 
public:
  // Propriétés Publiques (Interfaces)
  __property ISliteHardwareModel* ModelInterface = {read=FHardwareModelIntf};
 
__published:
  // Propriétés Publiées
  __property String ModelCode = {read=GetModelCode};
  __property String ModelName = {read=GetModelName};
};
 
//---------------------------------------------------------------------------
//                        TSliteHardwareProviderEntity                      -
//---------------------------------------------------------------------------
class TSliteHardwareProviderEntity : public TObject
{
  friend class TSliteHardwareProviderAbstractPersistentObject;
  friend class TSliteHardwareProviderConfigurator;
 
private:
  // Membres Privés
  TSliteHardwareProviderAbstractPersistentObject* FDeviceObject;
  ISliteHardwareEntity* FEntityIntf;
  TCriticalSection* FEntityIntfLock;
  TSliteHardwareProviderConfigurator* FConfigurator;
  bool FReady;
  TSliteHardwareProviderEntityBeforeReleaseEvent FOnBeforeRelease;
 
  // Méthodes Privées
  bool DeviceHasChanged(bool WithLock = true);
 
  // Accesseurs
  int __fastcall GetHardwarePrimaryID();
  TSliteHardwareProviderConfigurator* __fastcall GetConfigurator();
  ISliteHardwareEntity* __fastcall GetEntityIntf();
  bool ReleaseEntityIntf(bool WithLock = true, bool WithNotify = true);
  void DoBeforeReleaseEntityInterface(ISliteHardwareModel* AModelIntf, ISliteHardwareEntity* AEntityIntf);
 
protected:
  // Constructeurs Protégés (Masqués)
  /*constructor*/__fastcall TSliteHardwareProviderEntity(TSliteHardwareProviderAbstractPersistentObject* ADeviceObject);
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteHardwareProviderEntity();
 
  // Méthodes Publiques
  bool Use();
  bool Edit();
  bool Save();
  bool Delete();
  bool Close();
  bool CheckConfiguration(/*out*/String &Msg);
 
  // Propriétés Publiques
  __property int HardwarePrimaryID = {read=GetHardwarePrimaryID};
  __property TSliteHardwareProviderConfigurator* Configurator = {read=GetConfigurator};
  __property bool Ready = {read=FReady};
  __property TSliteHardwareProviderEntityBeforeReleaseEvent OnBeforeRelease = {read=FOnBeforeRelease, write=FOnBeforeRelease};
 
  // Propriétés Publiques (Interfaces)
  __property ISliteHardwareEntity* EntityInterface = {read=GetEntityIntf};
};
 
//---------------------------------------------------------------------------
//                     TSliteHardwareProviderConfigurator                   -
//---------------------------------------------------------------------------
class TSliteHardwareProviderConfigurator : public TObject
{
  friend class TSliteHardwareProviderEntity;
 
private:
  // Membres Privés
  TSliteHardwareProviderEntity* FEntity;
 
protected:
  // Constructeurs Protégés (Masqués)
  /*constructor*/__fastcall TSliteHardwareProviderConfigurator(TSliteHardwareProviderEntity* AEntity);
 
  // Accesseurs (propriétés publiques)
  ISliteHardwareConfigurationScreenInteractionDelphiInterface __fastcall GetInteractionInterface();
 
public:
  // Méthodes Publiques
  bool SetParent(TWinControl* AParent);
  bool ApplyChanges();
 
  // Propriétés Publiques
  __property TSliteHardwareProviderEntity* Entity = {read=FEntity};
  __property ISliteHardwareConfigurationScreenInteractionDelphiInterface InteractionInterface = {read=GetInteractionInterface};
};
 
//---------------------------------------------------------------------------
//            ESliteHardwareProviderAbstractPersistentObjectError           -
//---------------------------------------------------------------------------
class ESliteHardwareProviderAbstractPersistentObjectError : public ESliteORPersistentError
{
  typedef ESliteORPersistentError inherited;
 
private:
  String FInternalMsg;
 
public:
  /*constructor*/inline __fastcall ESliteHardwareProviderAbstractPersistentObjectError(const String Msg, int AErrorCode = 0, const String AInternalMsg = "") : inherited(Msg, AErrorCode), FInternalMsg(AInternalMsg) { }
 
  __property String InternalMessage = {read=FInternalMsg};
};
 
//---------------------------------------------------------------------------
//              TSliteHardwareProviderAbstractPersistentObject              -
//---------------------------------------------------------------------------
#pragma option push -w-diu // W8130 L'interface ne dérive pas de IUnknown.
class TSliteHardwareProviderAbstractPersistentObject : public TSliteORPersistent, public ISliteHardwareLinkedDevice
{
#pragma option pop
  friend class TSliteHardwareProviderEntity;
  typedef TSliteORPersistent inherited;
 
public:
  // Types Publiques
  enum TCheckErrorType {hpoceFriendlyNameIsEmpty, hpoceProviderIsEmpty, hpoceProviderModelCodeIsEmpty,
    hpoceProviderModelCodeIsInvalid, hpoceHardwareDetailIsInvalid, hpoceProviderCantBeSaved,
    hpoceDeviceCantBeSaved, hpoceHardwareEntityCantBeSaved,
    hpoceEnumCount}; // hpoceEnumCount doit être la dernière valeur !
 
private:
  // Membres Privés (propriétés publiées)
  TMemberString FFriendlyName;
  int FFriendlyDeviceNumber;
  TMemberString FModelCode;
 
  // Membres Privés
  TSliteHardwareProvider* FProvider;
  TSliteHardwareProviderEntity* FEntity;
 
  // Membres Privés (ISliteHardwareLinkedDevice)
  WideString FDeviceName; // shared BSTR
  WideString FDeviceString; // shared BSTR
 
  // Membres Privés (Thread)
  LONG FReferenceCount;
 
  // Méthodes Privées
  void LoadProviderByID(int NewID);
  void LoadProviderByDataSource();
  void LoadProviderModelByCode(const String ANewCode);
 
  TSQLQuery* SelectWhereDeviceNumber(int ADeviceNumber);
 
  void AssignDefaultAuthenticationBasic(ISliteHardwareEntityPurposeDelphiInterface &AEntityPurposeIntf);
 
  // Gestionnaires d'Evènement
  void __fastcall EntityBeforeReleaseEventHandler(TSliteHardwareProviderEntity * Sender, ISliteHardwareModel* AModelIntf, ISliteHardwareEntity* AEntityIntf);
 
protected:
  // Types internes
  enum TOptionalInterfacePropertyState {oidsNone, oidsSet, oidsNotSupported};
 
  // Membres Protégée
  TOptionalInterfacePropertyState FDefaultAuthenticationBasicState;
 
  // Accesseurs (propriétés publiées)
  // Do Not use reference parameter for published property setter
  TPropertyString __fastcall GetFriendlyName();
  void __fastcall SetFriendlyName(const TPropertyString Value);
  int __fastcall GetFriendlyDeviceNumber();
  void __fastcall SetFriendlyDeviceNumber(int Value);
  int __fastcall GetProviderID();
  void __fastcall SetProviderID(int Value);
  TPropertyString __fastcall GetProviderModelCode();
  void __fastcall SetProviderModelCode(const TPropertyString Value);
 
  // Méthodes Protégées
  void CheckDeviceHardwareDataBeforeSave(); // ne pas confondre avec CheckDataBeforeSave();
  bool UseEntity();
  bool EditEntity(TWinControl* AConfiguratorParent);
  bool ApplyChangesToEntity();
  bool CloseEntity();
 
  // Méthodes Abstraites Protégées devant être rédéfinies
  /*abstract*/virtual TSliteHardwareProviderManager* __fastcall GetProviderManagerInstance() = 0;
  /*abstract*/virtual bool AllowLoad() = 0;
 
  // Méthodes Protégées pouvant être rédéfinies
  virtual void CleanPurposeInterfaces();
 
  // Accesseurs (propriétés publiques)
  /*override*/virtual void __fastcall SetDataSource(TDataSource* Value);
  TSliteHardwareProvider* __fastcall GetProvider();
  TSliteHardwareProviderModel* __fastcall GetModel();
  TSliteHardwareProviderEntity* __fastcall GetEntity();
  ISliteHardwareEntityPurposeDelphiInterface __fastcall GetPurposeInterface();
 
  // Implementations of ISliteHardwareLinkedDevice Properties Accessors
  virtual ISliteHardwareLinkedDeviceManager* __fastcall GetDeviceManager();
  virtual int __fastcall GetDevicePrimaryID();
  virtual BSTR __fastcall GetDeviceName();
  virtual int __fastcall GetDeviceFriendlyNumber();
 
  // Propriétés Protégées pouvant être promues en Propriétés Publiques mais pas Publiées !
  __property TSliteHardwareProvider* Provider = {read=GetProvider};
  __property TSliteHardwareProviderModel* Model = {read=GetModel};
  __property TSliteHardwareProviderEntity* Entity = {read=GetEntity};
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteHardwareProviderAbstractPersistentObject();
  /*constructor*/__fastcall TSliteHardwareProviderAbstractPersistentObject(TDataSet* ADataSet);
  /*destructor*/virtual __fastcall ~TSliteHardwareProviderAbstractPersistentObject();
 
public:
  // Méthodes Publiques
  /*override*/virtual bool Load(int APrimaryID);
  virtual bool LoadByDeviceNumber(int ADeviceNumber);
  virtual bool LoadFromDataSource(); // Un objet lié à un DataSource doit être chargé pour atteindre toutes ses fonctionnalités !
  TSQLQuery* SelectByModel(const int AProviderID, const String AModelCode);
 
  /*override*/virtual bool Save();
  /*reintroduce*/HIDESBASE virtual bool Delete();
 
  virtual bool IsValidDevice();
  virtual bool IsReadyDevice();
  /*override*/virtual String __fastcall ToString();
 
  // Méthodes Redéfinies
  /*override*/__classmethod virtual bool IsRelation() {return false;}
 
  // Méthodes Publiques (Thread)
  int IncrementReference();
  int ReleaseReference();
 
  //Implementations of ISliteHardwareLinkedDevice Methods
  virtual BSTR __stdcall DeviceToString();
 
  // Propriétés Publiques
  __property ISliteHardwareEntityPurposeDelphiInterface PurposeInterface = {read=GetPurposeInterface};
 
__published:
  // Propriétés Publiées
  __property PrimaryID; // Augmentation de Visibilité
  __property TPropertyString FriendlyName = {read=GetFriendlyName, write=SetFriendlyName};
  __property int FriendlyDeviceNumber = {read=GetFriendlyDeviceNumber, write=SetFriendlyDeviceNumber};
  __property int ProviderID = {read=GetProviderID, write=SetProviderID};
  __property TPropertyString ProviderModelCode = {read=GetProviderModelCode, write=SetProviderModelCode};
 
public:
  static const TPropertyName PROP_NAME_HPO_FRIENDLY_NAME;
  static const TPropertyName PROP_NAME_HPO_FRIENDLY_DEVICE_NUMBER;
  static const TPropertyName PROP_NAME_HPO_PROVIDER_ID;
  static const TPropertyName PROP_NAME_HPO_PROVIDER_MODEL_CODE;
};
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
#endif

ça c'est un exemple d'encapsulation d'un SDK, ce n'est que la partie déclaration

Code c++ :

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
 
 
//---------------------------------------------------------------------------
#ifndef SliteDVRDahuaTechnologyLibraryClassesH
#define SliteDVRDahuaTechnologyLibraryClassesH
//---------------------------------------------------------------------------
#include <vcl.h>
#include <SyncObjs.hpp>
#include <System.Diagnostics.hpp>
//---------------------------------------------------------------------------
#include <vector>
#include <set>
#include <map>
//---------------------------------------------------------------------------
#include <winsock.h>
//---------------------------------------------------------------------------
#include "SupervisionGenericClasses.h"
//---------------------------------------------------------------------------
#include "dhnetsdk.h"
#include "WMPLib_OCX.h" // implique aussi "WMPLib_TLB.h"
//---------------------------------------------------------------------------
 
/* Forward Declarations */
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientManager;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientManagerNotifier;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClient;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientObject;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientObjectKeeper;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientSessionObject;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientGlobalObject;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientChannelObject;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientConfigurator;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientConfiguratorCache;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientConfiguratorCacheManager;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientTimeController;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientCustomView;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientDirectView;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientPlaybackView;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientViewControl;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientRecorder;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientTrigger;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientTriggerController;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientDownloader;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientAVIConverter;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientAVIConverterFromMonitorStream;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientAVIConverterFromFile;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientLazyTestConnection;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientFullyTestConnection;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyClientEventListener;
class RTL_DELPHICLASS TSliteDVRDahuaTechnologyReadWriteSynchronizer;
 
class ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable; // C++ interface
class ISliteDVRDahuaTechnologyClientTimeControllerEvent; // C++ interface
 
enum TSliteDVRDahuaTechnologyTestConnectionDepth : Byte;
enum TSliteDVRDahuaTechnologyTestConnectionResultType : Byte;
enum TSliteDVRDahuaTechnologyTimeControllerEventType : Byte;
enum TSliteDVRDahuaTechnologyWaitTimeLevel : Byte;
enum TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationType : int;
enum TSliteDVRDahuaTechnologyClientObjectState : int;
enum TSliteDVRDahuaTechnologyClientObjectError : int;
enum TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationType : Byte;
enum TSliteDVRDahuaTechnologyClientChannelObjectState : int;
enum TSliteDVRDahuaTechnologyClientChannelObjectError : int;
enum TSliteDVRDahuaTechnologyClientDownloaderStep : Byte;
enum TSliteDVRDahuaTechnologyClientAVIConverterStep : Byte;
enum TSliteDVRDahuaTechnologyVideoFrameFormat : BYTE;
enum TSliteDVRDahuaTechnologyVideoFrameSize : BYTE;
 
/* Forward Declarations */
class TUtilSytel;
 
typedef AnsiString DahuaCompatibleString; // Alias pour les chaines "Delphi" utilisées par les API Dahua
typedef DahuaCompatibleString DHString; // Short Alias
 
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyConnectionQuality                -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyConnectionQuality : Byte
  {dhcqNone, dhcqDefault, dhcqBest, dhcqBetter, dhcqCommon, dhcqWorse, dhcqWorst, dhcqEnumCount}; // dhcqEnumCount doit être la dernière valeur !
const TSliteDVRDahuaTechnologyConnectionQuality dhcqSession = dhcqDefault;
 
//---------------------------------------------------------------------------
//                     TSliteDVRDahuaTechnologyLoginError                   -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyLoginError : Byte
  {dhleIndefinedNetworkError, dhleInvalidPassWord, dhleInvalidAccount,
   dhleTimeOut, dhleAccountAlreadyLogged, dhleAccountLocked, dhleAccountBlackList,
   dhleSystemBusy, dhleIncompleteConnection, dhleInvalidHost, dhleTooMoreConnection
  };
 
//---------------------------------------------------------------------------
//                  TSliteDVRDahuaTechnologyClientErrorType                 -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientErrorType : Byte
  {dhceDirectoryCreateError,
   dhceRecordVideoPredefinedFileAlreadyExistsError,
   dhceRecordVideoConvertAVIMustAVIExtension,
   dhceRecordVideoForDownloadFileAlreadyExistsError
  };
 
//---------------------------------------------------------------------------
//                    ESliteDVRDahuaTechnologyClientError                   -
//---------------------------------------------------------------------------
class ESliteDVRDahuaTechnologyClientError : public Sysutils::Exception
{
  typedef Sysutils::Exception inherited;
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientErrorType FErrorType;
 
  // Accesseurs
  String __fastcall GetErrorTypeIdent() const;
 
public:
  // Constructeurs Publiques
  /*constructor*/inline __fastcall ESliteDVRDahuaTechnologyClientError(const String Msg, TSliteDVRDahuaTechnologyClientErrorType AErrorType) : inherited(Msg), FErrorType(AErrorType) { }
 
  // Propriétés Publiques
  __property TSliteDVRDahuaTechnologyClientErrorType ErrorType = {read=FErrorType};
  __property String ErrorTypeIdent = {read=GetErrorTypeIdent};
};
 
 
//---------------------------------------------------------------------------
//                  ESliteDVRDahuaTechnologyClientAssertion                 -
//---------------------------------------------------------------------------
class ESliteDVRDahuaTechnologyClientAssertion : public Sysutils::Exception
{
  typedef Sysutils::Exception inherited;
 
public:
  // Constructeurs Publiques
  /*constructor*/inline __fastcall ESliteDVRDahuaTechnologyClientAssertion(const String Msg) : inherited(Msg) { }
};
 
 
//---------------------------------------------------------------------------
//                   TSliteDVRDahuaTechnologyClientManager                  -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientManager [[final]] : public TObject
{
  friend class TSliteDVRDahuaTechnologyClientManagerNotifier;
 
private:
  // Membres Privés
  typedef TSliteGenericObjectList<TSliteDVRDahuaTechnologyClient> TSliteDVRDahuaTechnologyClientList;
  TSliteDVRDahuaTechnologyReadWriteSynchronizer* FThreadLock;
  TSliteDVRDahuaTechnologyClientList* FClientList;
  bool FInitialized;
  bool FFinalized;
  TSliteDVRDahuaTechnologyClientObjectKeeper* FClientObjectKeeper;
  bool FClientObjectKeeperStopped;
  TSliteDVRDahuaTechnologyClientManagerNotifier* FNotifier;
  bool FNotifierStopped;
  TSliteDVRDahuaTechnologyClientConfiguratorCacheManager* FConfiguratorCacheManager;
 
  // Méthodes Privées
  int IndexOfClient(const DHString AAddressIP, WORD APortTCP, const DHString ALogin, const DHString APassWord, TSliteDVRDahuaTechnologyConnectionQuality AConnectionQuality);
  int AddClient(TSliteDVRDahuaTechnologyClient *AClient);
  TSliteDVRDahuaTechnologyClient* GetClientByIndex(int Index);
 
  static void DeleteTemporaryFiles();
  static TFileName MakeVideoFileName(const TFileName AVideoDirectory, const String AVideoPrefix, const TDateTime AVideoTimeStamp, const String AExtension, bool AFormatDateTimeWithMilliSecondes = false);
 
  void StopNotifier();
  void StopKeeper();
 
  // CallBack
  friend void CALLBACK ClientDisconnectCallBack(LONG lLoginID, char *pchDVRIP, LONG nDVRPort, DWORD dwUser);
  friend void CALLBACK AutoReconnectCallBack(LONG lLoginID, char *pchDVRIP, LONG nDVRPort, DWORD dwUser);
  void AddSessionStatusInQueue(LONG lLoginID, char *pchDVRIP, LONG nDVRPort, bool AConnected);
  void NotifySessionStatus(LONG ALoginID, bool AConnected);
 
  friend BOOL CALLBACK ClientDVRMessageCallBack(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort, DWORD dwUser);
  void AddDVRMessageInQueue(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
  void NotifyDVRMessage(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
  static bool AcceptDVRMessage(LONG lCommand);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientManager();
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientManager();
 
  static TUtilSytel* UtilSytel;
 
  // Méthodes Publiques (Divers)
  void Cleanup();
  static void Trace(const UnicodeString ptrszLibelle, const UnicodeString ptrszExtenxionLib);
 
  static TSliteDVRDahuaTechnologyConnectionQuality IdentToConnectionQuality(const String Ident);
  static String ConnectionQualityToIdent(const TSliteDVRDahuaTechnologyConnectionQuality Value);
  static TSliteDVRDahuaTechnologyTestConnectionDepth IdentToTestConnectionDepth(const String Ident);
  static String TestConnectionDepthToIdent(const TSliteDVRDahuaTechnologyTestConnectionDepth Value);
 
  static String BuildErrorMessage(DWORD ADHLastError);
  static String BuildLoginErrorMessage(DWORD ADHLastError, TSliteDVRDahuaTechnologyLoginError DHLoginError);
 
  static TSize VideoFrameSizeToResolution(TSliteDVRDahuaTechnologyVideoFrameFormat AVideoFrameFormat, TSliteDVRDahuaTechnologyVideoFrameSize AVideoFrameSize);
 
  // Méthodes Publiques (Files)
  static TFileName GetTemporaryPath();
  static TFileName BuildVideoFileName(const TFileName AVideoDirectory, const String AVideoPrefix, const TDateTime AVideoTimeStamp, bool AConvertToAVI);
  static TFileName BuildVideoRemoteFileName(const TFileName AVideoDirectory, const TFileName AFileName);
  static TFileName BuildMotionVideoRemoteFileName(const TFileName AVideoDirectory, const NET_TIME &ADVRNetDateTime, const int ADuration);
  static bool SplitVideoRemoteFileName(const TFileName ARemoteFileName, /*out*/TFileName &AVideoDirectory, /*out*/TFileName &AFileName);
  static bool IsVideoFileName(const TFileName AFileName, /*out*/bool* AIsRemoteFile = NULL);
  static bool IsRemoteFile(const TFileName ARemoteFileName);
  static bool IsWindowsMediaPlayerFile(const TFileName ALocalFileName);
  static bool IsFileNameWithMotionStamp(const TFileName AFileName, /*out*/NET_TIME &AStartTime, /*out*/int &ADuration);
  static bool SimpleDirectoryExists(const TFileName ADirectory);
  static bool SimpleForceDirectories(const TFileName ADirectory);
  static __int64 GetFileSize(const TFileName AFileName);
 
  // Méthodes Publiques (Time)
  static String FormatDateTime(const String AFormat, TDateTime ADateTime);
  static NET_TIME DateTimeToDahuaNetTime(const TDateTime &ADateTime);
  static bool TryDahuaNetTimeToDateTime(const NET_TIME &ADVRNetDateTime, /*out*/TDateTime &ADateTime);
  static NET_TIME DHIncSecond(const NET_TIME &ADVRNetDateTime, int ASecond);
  static String DahuaNetTimeToString(const NET_TIME &ADVRNetDateTime);
  static bool TryStringToDahuaNetTime(const String S, /*out*/NET_TIME &ADVRNetDateTime);
 
  // Méthodes Publiques (Instances)
  TSliteDVRDahuaTechnologyClient* FindClient(const DHString AAddressIP, WORD APortTCP, const DHString ALogin, const DHString APassWord, TSliteDVRDahuaTechnologyConnectionQuality AConnectionQuality);
 
  __property TSliteDVRDahuaTechnologyClientObjectKeeper* ClientObjectKeeper = {read=FClientObjectKeeper};
  __property TSliteDVRDahuaTechnologyClientManagerNotifier* Notifier = {read=FNotifier};
  __property TSliteDVRDahuaTechnologyClientConfiguratorCacheManager* ConfiguratorCacheManager = {read=FConfiguratorCacheManager};
};
 
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
//              TSliteDVRDahuaTechnologyClientManagerNotifier               -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientManagerNotifier [[final]] : public TThread
{
  typedef TThread inherited;
  friend /*constructor*/ __fastcall TSliteDVRDahuaTechnologyClientManager::TSliteDVRDahuaTechnologyClientManager();
  friend /*method*/ void TSliteDVRDahuaTechnologyClientManager::AddSessionStatusInQueue(LONG lLoginID, char *pchDVRIP, LONG nDVRPort, bool AConnected);
  friend /*method*/ void TSliteDVRDahuaTechnologyClientManager::AddDVRMessageInQueue(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientManager *FClientManager;
  TThreadList* FNotifyList;
  TEvent* FWaitEvent;
 
  enum TNotifyType : Byte {ntNone, ntStatus, ntMessage};
  struct TNotifyItem
  {
    LONG lLoginID;
    char *pchDVRIP;
    LONG nDVRPort;
 
    TNotifyType NotifyType;
    union
    {
      struct
      {
        bool Connected;
      } Status;
      struct
      {
        LONG lCommand;
        char *pBuf;
        DWORD dwBufLen;
      } Message;
    };
  };
 
  // Constructeurs Privés (Masqués)
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientManagerNotifier(TSliteDVRDahuaTechnologyClientManager *AClientManager);
 
  // Méthodes Privées (Réservées aux Amis)
  void Add(TNotifyItem* ANotifyItem);
 
protected:
  // Méthodes Protégées Redéfinies (TThread)
  /*override*/virtual void __fastcall Execute(void);
  /*override*/virtual void __fastcall TerminatedSet(void);
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientManagerNotifier();
};
 
 
//---------------------------------------------------------------------------
//                       TSliteDVRDahuaTechnologyClient                     -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClient : public TObject
{
  friend /*method*/ TSliteDVRDahuaTechnologyClient* TSliteDVRDahuaTechnologyClientManager::FindClient(const DHString AAddressIP, WORD APortTCP, const DHString ALogin, const DHString APassWord, TSliteDVRDahuaTechnologyConnectionQuality AConnectionQuality);
  friend /*method*/ void TSliteDVRDahuaTechnologyClientManager::NotifySessionStatus(LONG ALoginID, bool AConnected);
  friend /*method*/ void TSliteDVRDahuaTechnologyClientManager::NotifyDVRMessage(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
  friend class TSliteDVRDahuaTechnologyClientObject;
  friend class TSliteDVRDahuaTechnologyClientSessionObject;
  friend class TSliteDVRDahuaTechnologyClientChannelObject;
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientManager *FClientManager;
  DHString FAddressIP;
  IN_ADDR FAddressIPValue;
  WORD FPortTCP;
  DHString FLogin;
  DHString FPassWord;
  TSliteDVRDahuaTechnologyConnectionQuality FConnectionQuality;
  DWORD FDHLastError;
  TSliteDVRDahuaTechnologyLoginError FDHLoginError;
 
  typedef int TChannelID;
  // Membres Privés (Vues)
  typedef struct
  {
    typedef struct
    {
      LONG LoginID;
      bool Connected;
      struct
      {
        BOOL Standard;
        BOOL Enhanced;
      } ListeningDeviceMessage;
      NET_DEVICEINFO DeviceInfo;
      DWORD DHLastError;
    } TLoginInfoData;
    TLoginInfoData Data;
    typedef std::map<TChannelID, TSliteDVRDahuaTechnologyClientChannelObject*> TChannelObjectMap;
    TChannelObjectMap ChannelObjects;
  } TLoginInfo;
  typedef std::vector<TLoginInfo*> TLoginInfoList;
  TLoginInfoList FClientLogins;
  typedef TSliteGenericObjectList<TSliteDVRDahuaTechnologyClientSessionObject> TSessionObjectList;
  TSessionObjectList* FSessionObjects;
  TSliteDVRDahuaTechnologyReadWriteSynchronizer* FClientLoginsLock; // Protège les TLoginInfo donc implicite les ChannelObject !
  TSliteDVRDahuaTechnologyReadWriteSynchronizer* FSessionObjectsLock; // Protège SessionObject,
  TSliteDVRDahuaTechnologyClientTriggerController* FTriggerController;
  TSliteDVRDahuaTechnologyClientTimeController* FTimeController;
 
  // Méthodes Privées
  bool ConnectChannelObject(TSliteDVRDahuaTechnologyClientChannelObject *AChannelObject);
  bool ConnectSessionObject(TSliteDVRDahuaTechnologyClientSessionObject *ASessionObject);
  bool DisconnectClientObject(TSliteDVRDahuaTechnologyClientObject *AClientObject);
 
  bool SeekFreeConnection(TChannelID AChannelID, TLoginInfo* &ALoginInfo);
  bool SeekConnection(TLoginInfo* &ALoginInfo);
  bool SeekConnectionByLoginID(LONG ALoginID, TLoginInfo* &ALoginInfo);
  bool OpenConnection(TLoginInfo* &ALoginInfo);
  bool CloseConnection(TLoginInfo *ALoginInfo);
  bool CloseUnusedConnection(TLoginInfo *ALoginInfo);
  bool CloseUnusedConnection(TLoginInfoList::iterator AIterator);
 
  bool AddChannelObjectInConnection(TLoginInfo *ALoginInfo, TSliteDVRDahuaTechnologyClientChannelObject *AChannelObject);
  bool AddSessionObjectInConnection(TLoginInfo *ALoginInfo, TSliteDVRDahuaTechnologyClientSessionObject *ASessionObject);
  bool RemoveChannelObjectInConnection(TLoginInfo *ALoginInfo, TSliteDVRDahuaTechnologyClientChannelObject *AChannelObject);
  bool RemoveClientObjectInConnection(TLoginInfo *ALoginInfo, TSliteDVRDahuaTechnologyClientObject *AClientObject);
  bool RemoveSessionObjectInConnection(TLoginInfo *ALoginInfo, TSliteDVRDahuaTechnologyClientSessionObject *ASessionObject);
  bool UseBySessionObject(LONG ALoginID);
 
  BOOL StartListenDeviceMessage(TLoginInfo *ALoginInfo, bool EnhancedVersion);
  BOOL StopListenDeviceMessage(TLoginInfo *ALoginInfo);
 
  // CallBack
  void NotifySessionStatus(LONG lLoginID, bool AConnected);
  void NotifyDVRMessage(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
 
private:
  // Constructeurs Privés (Masqués)
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClient(TSliteDVRDahuaTechnologyClientManager *AClientManager, const DHString AAddressIP, WORD APortTCP, const DHString ALogin, const DHString APassWord, TSliteDVRDahuaTechnologyConnectionQuality AConnectionQuality);
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClient();
 
  // Méthodes Publiques
  bool IsCompatible(const DHString AAddressIP, WORD APortTCP, const DHString ALogin, const DHString APassWord, TSliteDVRDahuaTechnologyConnectionQuality AConnectionQuality);
 
  // Méthodes Publiques (Session)
  BOOL StartListenDeviceMessage(LONG ALoginID, bool EnhancedVersion);
  BOOL StopListenDeviceMessage(LONG ALoginID);
  BYTE GetChannelCount(LONG ALoginID);
 
  // Propriétés Publiques
  __property TSliteDVRDahuaTechnologyClientManager* ClientManager = {read=FClientManager};
  __property DWORD DHLastError = {read=FDHLastError};
  __property TSliteDVRDahuaTechnologyLoginError DHLoginError = {read=FDHLoginError};
  __property TSliteDVRDahuaTechnologyConnectionQuality ConnectionQuality = {read=FConnectionQuality};
  __property TSliteDVRDahuaTechnologyClientTriggerController* TriggerController = {read=FTriggerController};
  __property TSliteDVRDahuaTechnologyClientTimeController* TimeController = {read=FTimeController};
};
 
//---------------------------------------------------------------------------
//                   TSliteDVRDahuaTechnologyWaitTimeLevel                  -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyWaitTimeLevel : Byte
  {dhtwtlShort, dhtwtlBasic, dhtwtlMedium, dhtwtlLong, dhtwtlEnumCount}; // dhtwtlEnumCount doit être la dernière valeur et Ne pas changer l'ordre !
 
//---------------------------------------------------------------------------
//      TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationEvent     -
//---------------------------------------------------------------------------
typedef void __fastcall (__closure *TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationEvent)(TSliteDVRDahuaTechnologyClientObject* Sender, TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationType ANotificationType, int ANotificationCode);
 
//---------------------------------------------------------------------------
//       TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationType     -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationType : int
  {dhcoanState, dhcoanError};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientObjectState                 -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientObjectState : int
  {dhcosAutoReconnect};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientObjectError                 -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientObjectError : int
  {dhcoeUnexpectedLogout};
 
//---------------------------------------------------------------------------
//                   TSliteDVRDahuaTechnologyClientObject                   -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientObject : public TObject
{
  friend /*method*/ void TSliteDVRDahuaTechnologyClient::NotifySessionStatus(LONG lLoginID, bool AConnected);
 
private:
  // Membres Privées
  bool FSessionConnected;
  TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationEvent FOnAsynchroneNotification;
 
  // Méthodes Privées
 
  // CallBack
  void NotifySessionStatus(LONG lLoginID, bool AConnected);
 
protected:
  // Membres Protégés
  TSliteDVRDahuaTechnologyClient* FClient;
  TSliteDVRDahuaTechnologyClientManager *FClientManager;
  LONG FLoginID;
  DWORD FDHLastError;
 
  // Méthodes virtuelles redéfinissables
  virtual bool AcceptSessionStatus(LONG ALoginID);
  virtual void TreatUnexpectedLogout();
  virtual void TreatAutoReconnect();
 
  // Méthodes Protégées
  int GetWaitTime(TSliteDVRDahuaTechnologyWaitTimeLevel ALevel);
 
  // Générateurs d'Evènement
  void __fastcall DoAsynchroneNotification(TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationType ANotificationType, int ANotificationCode);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientObject(TSliteDVRDahuaTechnologyClient *AClient);
 
  // Méthodes Publiques
  virtual bool ChangeSession(LONG ALoginID);
 
  // Propriétés Publiques
  __property TSliteDVRDahuaTechnologyClient* Client = {read=FClient};
  __property TSliteDVRDahuaTechnologyClientManager* ClientManager = {read=FClientManager};
  __property LONG LoginID = {read=FLoginID};
  __property DWORD DHLastError = {read=FDHLastError};
  __property bool SessionConnected = {read=FSessionConnected};
 
  __property TSliteDVRDahuaTechnologyClientObjectAsynchroneNotificationEvent OnAsynchroneNotification = {read=FOnAsynchroneNotification, write=FOnAsynchroneNotification};
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientObjectKeeper                -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientObjectKeeper : public TThread
{
  typedef TThread inherited;
  friend /*constructor*/ __fastcall TSliteDVRDahuaTechnologyClientManager::TSliteDVRDahuaTechnologyClientManager();
 
private:
  // Membres Privés
  TThreadList* FIneradicableList;
  TThreadList* FIneradicableHastyList;
  TEvent* FWaitEvent;
 
  // Constructeurs Privés (Masqués)
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientObjectKeeper();
 
protected:
  // Méthodes Protégées Redéfinies (TThread)
  /*override*/virtual void __fastcall Execute(void);
  /*override*/virtual void __fastcall TerminatedSet(void);
 
public:
  // Constructeurs Publiques
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientObjectKeeper();
 
  // Méthodes Publiques
  void Add(ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable *AIneradicable);
  void Remove(ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable *AIneradicable);
  void WakeUpFor(ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable *AIneradicable);
};
 
//---------------------------------------------------------------------------
//         ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable           -
//---------------------------------------------------------------------------
class ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable
{
public:
  // Interface Methods
  virtual void KeepAlive() = 0;
};
 
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientSessionObject               -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientSessionObject : public TSliteDVRDahuaTechnologyClientObject
{
  typedef TSliteDVRDahuaTechnologyClientObject inherited;
 
private:
  // Membres Privés
  bool FOpened;
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientSessionObject(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientSessionObject();
 
  virtual bool OpenSession();
  virtual bool CloseSession();
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientGlobalObject                -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientGlobalObject : public TSliteDVRDahuaTechnologyClientObject
{
  typedef TSliteDVRDahuaTechnologyClientObject inherited;
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientGlobalObject(TSliteDVRDahuaTechnologyClient *AClient);
};
 
//---------------------------------------------------------------------------
//  TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationEvent  -
//---------------------------------------------------------------------------
typedef void __fastcall (__closure *TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationEvent)(TSliteDVRDahuaTechnologyClientChannelObject* Sender, TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationType ANotificationType, int ANotificationCode);
 
//---------------------------------------------------------------------------
//   TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationType  -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationType : Byte
  {dhccoanChannelState, dhccoanChannelError};
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientChannelObjectState             -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientChannelObjectState : int
  {dhccosHaveVideo};
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientChannelObjectError             -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientChannelObjectError : int
  {dhccoeVideoLost};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientChannelObject               -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientChannelObject : public TSliteDVRDahuaTechnologyClientObject
{
  typedef TSliteDVRDahuaTechnologyClientObject inherited;
  friend /*method*/ void TSliteDVRDahuaTechnologyClient::NotifyDVRMessage(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen, char *pchDVRIP, LONG nDVRPort);
 
private:
  // Membres Privés
  bool FOpened;
 
  // CallBack
  void NotifyDVRMessage(LONG lCommand, LONG lLoginID, char *pBuf, DWORD dwBufLen);
  static bool AcceptDVRMessage(LONG lCommand);
 
protected:
  // Membres Protégés
  TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationEvent FOnAsynchroneChannelNotification;
 
  typedef int TChannelID;
  TChannelID FChannelID;
  LONG FMonitorID;
  bool FChannelConnected;
  bool FVideoLost;
 
  // Méthodes Protégées
  /*override*/virtual void TreatUnexpectedLogout();
  /*override*/virtual void TreatAutoReconnect();
  virtual void TreatDVRMessage(LONG lCommand, char *pBuf, DWORD dwBufLen);
  virtual void TreatVideoLost(bool InAlarm);
 
  // Générateurs d'Evènement
  void __fastcall DoAsynchroneChannelNotification(TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationType ANotificationType, int ANotificationCode);
 
  // Accesseurs
  TChannelID __fastcall GetChannelID();
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientChannelObject(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientChannelObject();
 
  // Méthodes Publiques
  virtual bool OpenChannel(TChannelID AChannelID);
  virtual bool CloseChannel();
 
  static bool HaveVideo(LONG ALoginID, TChannelID AChannelID, /*out*/DWORD *ADHError = NULL, int waittime=1000);
  static bool IsInRecording(LONG ALoginID, TChannelID AChannelID, /*out*/DWORD *ADHError = NULL, int waittime=1000);
 
  // Propriétés Publiques
  __property TChannelID ChannelID = {read=GetChannelID};
  __property LONG MonitorID = {read=FMonitorID};
  __property bool ChannelConnected = {read=FChannelConnected};
 
  __property TSliteDVRDahuaTechnologyClientChannelObjectAsynchroneNotificationEvent OnAsynchroneChannelNotification = {read=FOnAsynchroneChannelNotification, write=FOnAsynchroneChannelNotification};
};
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyVideoFrameFormat                 -
//---------------------------------------------------------------------------
// conçu pour être compatible avec :
// - tagVideoFrameParam.format
// - DHDEV_SYSTEM_ATTR_CFG.byVideoStandard
// => 0 = PAL et 1 = NTSC
enum TSliteDVRDahuaTechnologyVideoFrameFormat : BYTE
  {dhvffPAL, dhvffNTSC, dhvffEnumCount, dhvffUnknown}; // dhvffEnumCount et dhvffUnknown doivent être les dernières valeurs !
const TSliteDVRDahuaTechnologyVideoFrameFormat dhvffFirst = dhvffPAL;
 
//---------------------------------------------------------------------------
//                  TSliteDVRDahuaTechnologyVideoFrameSize                  -
//---------------------------------------------------------------------------
// conçu pour être compatible avec tagVideoFrameParam.size
enum TSliteDVRDahuaTechnologyVideoFrameSize : BYTE
 {
   dhvfsCIF, dhvfsHD1, dhvfs2CIF, dhvfsD1, dhvfsVGA, dhvfsQCIF, dhvfsQVGA, dhvfsSVCD,
   dhvfsQQVGA, dhvfsSVGA, dhvfsXVGA, dhvfsWXGA, dhvfsSXGA, dhvfsWSXGA, dhvfsUXGA, dhvfsWUXGA,
   dhvfsEnumCount, dhvfsUnknown
 }; // dhvfsEnumCount et dhvfsUnknown doivent être les dernières valeurs !
// CIF, abréviation de "Common Intermediate Format"
const TSliteDVRDahuaTechnologyVideoFrameSize dhvfsFirst = dhvfsCIF;
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyClientCustomView                 -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientCustomView : public TSliteDVRDahuaTechnologyClientChannelObject
{
  typedef TSliteDVRDahuaTechnologyClientChannelObject inherited;
 
private:
  // Membres Privés
  TNotifyEvent FOnClick;
  TMouseMoveEvent FOnMouseMove;
  TNotifyEvent FOnMouseLeave;
 
  TWinControl* FParent;
  HWND FParentHandle;
  TSliteDVRDahuaTechnologyClientViewControl* FControl;
 
  // Accesseurs
  String __fastcall GetResolutionName();
 
protected:
  // Méthodes Protégées
  virtual TSliteDVRDahuaTechnologyClientViewControl* ControlFactory();
  virtual TSliteDVRDahuaTechnologyClientViewControl* CreateControl(TWinControl *AParent);
  virtual void AcceptControl(TSliteDVRDahuaTechnologyClientViewControl* AControl);
  virtual void ReleaseControl();
 
  // Méthodes Abstraites
  /*abstract*/virtual LONG CreateMonitor(TSliteDVRDahuaTechnologyClientViewControl *AControl) = 0;
  /*abstract*/virtual bool ReleaseMonitor(LONG AMonitorID) = 0;
 
  // Accesseurs Abstraits
  /*abstract*/virtual TSliteDVRDahuaTechnologyVideoFrameFormat GetVideoFrameFormat() = 0;
  /*abstract*/virtual TSliteDVRDahuaTechnologyVideoFrameSize GetVideoFrameSize() = 0;
 
  // Accesseurs Protégés
  TSliteDVRDahuaTechnologyClientViewControl* __fastcall GetControl();
 
  // Evènements
  void __fastcall ClickEventHandler(TObject* Sender);
  virtual void __fastcall DoClick();
  void __fastcall MouseMoveEventHandler(TObject* Sender, TShiftState Shift, int X, int Y);
  virtual void __fastcall DoMouseMove(TShiftState Shift, int X, int Y);
  void __fastcall MouseLeaveEventHandler(TObject* Sender);
  virtual void __fastcall DoMouseLeave();
 
  // Propriétés Protégées
  __property TWinControl* Parent = {read=FParent};
  __property HWND ParentHandle = {read=FParentHandle};
  __property TSliteDVRDahuaTechnologyClientViewControl* Control = {read=FControl};
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientCustomView(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientCustomView();
 
  // Méthodes Publiques
  /*override*/virtual bool CloseChannel();
 
  // Méthodes Publiques
  bool SetViewParentVCL(TWinControl *AParent);
 
  // Propriétés Publiques
  __property TSliteDVRDahuaTechnologyVideoFrameFormat VideoFrameFormat = {read=GetVideoFrameFormat};
  __property TSliteDVRDahuaTechnologyVideoFrameSize VideoFrameSize = {read=GetVideoFrameSize};
 
  // Evènements Publiques
  __property TNotifyEvent OnClick = {read=FOnClick, write=FOnClick};
  __property TMouseMoveEvent OnMouseMove = {read=FOnMouseMove, write=FOnMouseMove};
  __property TNotifyEvent OnMouseLeave = {read=FOnMouseLeave, write=FOnMouseLeave};
};
 
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyClientDirectView                 -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientDirectView [[final]] : public TSliteDVRDahuaTechnologyClientCustomView
{
  typedef TSliteDVRDahuaTechnologyClientCustomView inherited;
  friend void CALLBACK DirectViewRealDataCallBackEx(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize, LONG param, DWORD dwUser);
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientRecorder* FRecorder;
  TStringList *FDirectRecords;
 
  bool FReadRealData;
  BOOL FRealDataCallBackExInstalled;
 
  TSliteDVRDahuaTechnologyVideoFrameFormat FVideoFrameFormat;
  TSliteDVRDahuaTechnologyVideoFrameSize FVideoFrameSize;
  enum TVideoFrameState {vfsNone, vfsReading, vfsRead};
  TVideoFrameState FVideoFrameState;
 
  // Accesseurs
  TFileName GetCurrentDirectRecordFileName();
  TStrings* __fastcall GetDirectRecords();
 
  // Méthodes Privées
  void NotifyRealDataCallBackEx(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize, LONG param, DWORD dwUser);
  bool InstallRealDataCallBackEx(LONG AMonitorID);
  void UninstallRealDataCallBackEx(LONG AMonitorID);
 
protected:
  // Méthodes Abstraites rédéfinies
  /*override*/virtual LONG CreateMonitor(TSliteDVRDahuaTechnologyClientViewControl *AControl);
  /*override*/virtual bool ReleaseMonitor(LONG AMonitorID);
 
  // Accesseurs Abstraits rédéfinies
  /*override*/virtual TSliteDVRDahuaTechnologyVideoFrameFormat GetVideoFrameFormat();
  /*override*/virtual TSliteDVRDahuaTechnologyVideoFrameSize GetVideoFrameSize();
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientDirectView(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientDirectView();
 
  // Méthodes Publiques
  /*override*/virtual bool CloseChannel();
 
  // Méthodes Publiques
  bool SnapshotToBitmap(Graphics::TBitmap *ASnapshot);
 
  bool StartDirectRecord(const TFileName AVideoDirectory, const String AVideoPrefix, bool AConvertToAVI);
  bool StopDirectRecord();
 
  // Propriétés Publiques
  __property bool ReadRealData = {read=FReadRealData, write=FReadRealData}; // Activation du CallBack !
  __property TFileName CurrentDirectRecordFileName = {read=GetCurrentDirectRecordFileName};
  __property TStrings *DirectRecords = {read=GetDirectRecords};
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientPlaybackView                -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientPlaybackView [[final]] : public TSliteDVRDahuaTechnologyClientCustomView
{
  typedef TSliteDVRDahuaTechnologyClientCustomView inherited;
 
  friend void CALLBACK ClientPlaybackViewDownLoadPosCallBack(LONG lPlayHandle, DWORD dwTotalSize, DWORD dwDownLoadSize, DWORD dwUser);
  friend BOOL CALLBACK ClientPlaybackViewEnumWindowsProc(HWND hwnd, LPARAM lParam);
 
private:
  // Types Privés
  enum TPlaybackFileType : Byte {pbftUnknown, pbftLocal, pbftNet};
  enum TPlaybackFileSubType : Byte {pbftNA, pbfstNetFromTrigger, pbfstNetFromMotion};
  struct TPlaybackFileInfo
  {
    TPlaybackFileType FileType;
    TPlaybackFileSubType FileSubType;
    String FileName;
    struct
    {
      union
      {
        struct
        {
          NET_TIME NetStartTime;
          NET_TIME NetStopTime;
        } Trigger;
        struct
        {
          NET_TIME NetStartTime;
          int Duration;
        } Motion;
      };
    } NetFile;
 
    TPlaybackFileType SetFileName(const TFileName AFileName);
  };
  TPlaybackFileInfo FPlaybackFileInfo;
  bool FMustLocal;
 
  static TFileName FDAVPlayer;
  static TFileName FAVIPlayer;
 
  bool FIntegratedView;
  bool FIntegratedWindowsMediaPlayer;
  TWindowsMediaPlayer* FWindowsMediaPlayer;
 
  bool FIncoherentCallBack;
  TNotifyEvent FOnPlaybackOver;
 
  String FLastSysErrorMessage;
  String FPaintText;
 
  TNotifyEvent FOnClick;
 
  DWORD FProcessID;
 
  typedef std::vector<HWND> TProcessHWndList;
  struct TEnumWindowsParams
  {
    DWORD FProcessID;
    TProcessHWndList FProcessHWndList;
 
    /*constructor*/TEnumWindowsParams(DWORD AProcessID) : FProcessID(AProcessID) {}
    void Add(HWND hwnd);
  };
 
  // Méthodes Privées
  void NotifyDownLoadPosCallBack(LONG lPlayHandle, DWORD dwTotalSize, DWORD dwDownLoadSize);
  /*static*/int AlignLocalViewerWindows(DWORD AProcessID, TSliteDVRDahuaTechnologyClientViewControl* AViewControl, bool Forced = false);
 
protected:
  // Méthodes Protégées rédéfinies
  /*override*/virtual TSliteDVRDahuaTechnologyClientViewControl* ControlFactory();
 
  // Méthodes Abstraites rédéfinies
  /*override*/virtual LONG CreateMonitor(TSliteDVRDahuaTechnologyClientViewControl *AControl);
  /*override*/virtual bool ReleaseMonitor(LONG AMonitorID);
 
  // Méthodes Protégées
  LONG CreateMonitorWMP(TSliteDVRDahuaTechnologyClientViewControl *AControl);
  LONG CreateMonitorShell(TSliteDVRDahuaTechnologyClientViewControl *AControl);
  LONG CreateMonitorRemote(TSliteDVRDahuaTechnologyClientViewControl *AControl);
 
  // Accesseurs Abstraits rédéfinies
  /*override*/virtual TSliteDVRDahuaTechnologyVideoFrameFormat GetVideoFrameFormat();
  /*override*/virtual TSliteDVRDahuaTechnologyVideoFrameSize GetVideoFrameSize();
 
  // Evènements
  /*override*/virtual void __fastcall DoClick();
 
  // Gestionnaires d'Evènements
  void __fastcall PaintEventHandler(TObject* Sender);
  void __fastcall EraseBkgndEventHandler(TObject* Sender);
  void __fastcall WMPMouseMove(TObject *Sender, short nButton/*[in]*/, short nShiftState/*[in]*/, long fX/*[in]*/, long fY/*[in]*/);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientPlaybackView(TSliteDVRDahuaTechnologyClient *AClient);
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientPlaybackView();
 
  // Méthodes Publiques
  /*override*/virtual bool OpenChannel(TChannelID AChannelID);
 
  // Méthodes Publiques
  bool LoadFromFile(const TFileName AFileName);
  bool Pause();
  bool Resume();
 
  // Méthodes de Classe
  static bool RegisterDAVPlayer(const TFileName AFileName);
  static bool RegisterAVIPlayer(const TFileName AFileName);
 
  // Propriétés Publiques
  __property String LastSysErrorMessage = {read=FLastSysErrorMessage};
  __property bool IntegratedView = {read=FIntegratedView};
  __property bool IntegratedWindowsMediaPlayer = {read=FIntegratedWindowsMediaPlayer, write=FIntegratedWindowsMediaPlayer};
 
  // Evènements Publiques
  __property TNotifyEvent OnClick = {read=FOnClick, write=FOnClick};
  __property TNotifyEvent OnPlaybackOver = {read=FOnPlaybackOver, write=FOnPlaybackOver};
};
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyClientViewControl                -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientViewControl : public TCustomControl
{
  typedef TCustomControl inherited;
 
private:
  // Membres Privés
  bool FAllowEraseBkgnd;
  bool FAllowPaint;
  TNotifyEvent FOnPaint;
  TNotifyEvent FOnEraseBkgnd;
 
  // Méthodes Privées
  void __fastcall WMEraseBkgnd(TWMEraseBkgnd &AMessage);
 
protected:
  // Méthodes Protégées rédéfinies
  /*override*/virtual void __fastcall Paint(void);
  /*override*/virtual void __fastcall CreateParams(TCreateParams &Params);
 
public:
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientViewControl(bool AllowPaint = false, bool AllowEraseBkgnd = false);
 
  // Propriétés Publiques
  __property Canvas;
 
  // Evènements Publiques
  __property OnClick;
  __property OnMouseMove;
  __property OnMouseLeave;
  __property TNotifyEvent OnPaint = {read=FOnPaint, write=FOnPaint};
  __property TNotifyEvent OnEraseBkgnd = {read=FOnEraseBkgnd, write=FOnEraseBkgnd};
 
  BEGIN_MESSAGE_MAP
    VCL_MESSAGE_HANDLER(WM_ERASEBKGND, TWMEraseBkgnd, WMEraseBkgnd);
  END_MESSAGE_MAP(TCustomControl)
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientLocalFileType               -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientLocalFileType : Byte
  {dhclftUseFileNameExtension, dhclftDAV, dhclftAVI};
 
//---------------------------------------------------------------------------
//            TSliteDVRDahuaTechnologyClientAVIConverterStepEvent           -
//---------------------------------------------------------------------------
typedef void __fastcall (__closure *TSliteDVRDahuaTechnologyClientAVIConverterStepEvent)(TSliteDVRDahuaTechnologyClientAVIConverter* Sender, TSliteDVRDahuaTechnologyClientAVIConverterStep AStep, const __int64 APosition, const __int64 ASize);
 
//---------------------------------------------------------------------------
//              TSliteDVRDahuaTechnologyClientAVIConverterStep              -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientAVIConverterStep : Byte
  {dhcacsStart, dhcacsProgress, dhcacsEnd, dhcacsAbort};
 
//---------------------------------------------------------------------------
//                  TSliteDVRDahuaTechnologyClientRecorder                  -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientRecorder [[final]] : public TSliteDVRDahuaTechnologyClientChannelObject
{
  typedef TSliteDVRDahuaTechnologyClientChannelObject inherited;
  friend /*method*/ bool TSliteDVRDahuaTechnologyClientDirectView::StartDirectRecord(const TFileName AVideoDirectory, const TFileName AVideoPrefix, bool AConvertToAVI);
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientDirectView* FClientDirectView;
  TSliteDVRDahuaTechnologyClientAVIConverter* FAVIConverter;
 
  DHString FCurrentDirectRecordFileName;
 
  bool FSavingRealData;
  bool FSavingByConverter;
  bool FSavingByDifferedConverter;
  LONG FFileID;
  DWORD FTotalSize;
 
protected:
  // Méthodes Protégées
  /*override*/virtual void TreatUnexpectedLogout();
  /*override*/virtual void TreatVideoLost(bool InAlarm);
 
private:
  // Constructeurs Privés (Masqués)
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientRecorder(TSliteDVRDahuaTechnologyClientDirectView *AClientDirectView);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientRecorder(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientRecorder();
 
  // Méthodes Publiques
  /*override*/virtual bool OpenChannel(TChannelID AChannelID);
  /*override*/virtual bool CloseChannel();
 
  bool StartDirectRecord(const TFileName AVideoDirectory, const String AVideoPrefix, bool AConvertToAVI); /*overload*/
  bool StartDirectRecord(const DHString AVideoFileName, TSliteDVRDahuaTechnologyClientLocalFileType AFileType); /*overload*/
  bool StopDirectRecord(bool Forced = false);
 
  // Propriétés Publiques
  __property TSliteDVRDahuaTechnologyClientDirectView* ClientDirectView = {read=FClientDirectView};
  __property DHString CurrentDirectRecordFileName = {read=FCurrentDirectRecordFileName};
};
 
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientTriggerController              -
//---------------------------------------------------------------------------
#pragma option push -w-diu // W8130 L'interface ne dérive pas de IUnknown.
class TSliteDVRDahuaTechnologyClientTriggerController [[final]] : public TSliteDVRDahuaTechnologyClientGlobalObject,
  public ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable
{
#pragma option pop
  typedef TSliteDVRDahuaTechnologyClientGlobalObject inherited;
 
private:
  // Membres Privés
  unsigned AlarmCounters[DH_MAX_CHANNUM];
  bool AlarmErrors[DH_MAX_CHANNUM];
  TCriticalSection* FAlarmLock;
  TObjectList* FTriggers;
  bool FUnstableSession;
  LONG FLastLoginID;
  TObject* FKeepingAlive;
  bool FKept;
 
  // Méthodes Privées
  bool InternalCloseTrigger(int AAlarmNo);
 
  void StabilizeTriggerWithLastSession();
  bool SetTriggerToTheoricState(LONG ALoginID);
  void ForceZeroCounters();
 
  void LockCounter();
  void UnlockCounter();
  void LockKeeper();
  void UnlockKeeper();
  void AddToKeeper();
 
protected:
  // Méthodes virtuelles redéfinissables
  /*override*/virtual bool AcceptSessionStatus(LONG ALoginID);
  /*override*/virtual void TreatUnexpectedLogout();
  /*override*/virtual void TreatAutoReconnect();
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientTriggerController(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientTriggerController();
 
  // Méthodes Publiques
  bool OpenTrigger(int AAlarmNo);
  bool CloseTrigger(int AAlarmNo);
  bool AbortTrigger(int AAlarmNo, bool DecCounter);
 
  void Attach(TSliteDVRDahuaTechnologyClientTrigger* ATrigger);
  void Detach(TSliteDVRDahuaTechnologyClientTrigger* ATrigger);
 
  /*override*/virtual bool ChangeSession(LONG ALoginID);
 
  // Implementations of ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable Methods
  virtual void KeepAlive();
};
 
 
//---------------------------------------------------------------------------
//                  TSliteDVRDahuaTechnologyClientTrigger                   -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientTrigger [[final]] : public TSliteDVRDahuaTechnologyClientSessionObject
{
  typedef TSliteDVRDahuaTechnologyClientSessionObject inherited;
 
public:
  // Types Publiques
  typedef int TChannelID;
  typedef int TMinutes;
  typedef int TSeconds;
  struct TTriggerAlarmOptions
  {
    TSeconds ToleratedLatencyOfRecordReally;
    TMinutes ConfiguratorCacheLifeTime;
  };
  struct TTriggerAlarmResultBase
  {
    TChannelID ChannelID;
    bool Started;
    bool StartError;
    bool StopOrAbordRequested;
    bool Stopped;
    bool StopError;
    bool StopAnticipated;
    bool Aborted;
    bool AbortError;
    bool Finished;
    bool HaveOpenMode;
    bool OpenMode;
    bool RecordForced;
    bool RecordPlanned;
    bool RecordStateUnknown;
    bool RecordAsked;
    bool RecordInTime;
    bool RecordReally;
    bool RecordActive;
    bool RecordPermanent;
    TSeconds PreRecordLen;
    TSeconds AlarmDuration;
    TSeconds PostRecordLen;
    TDateTime LocalStartTime;
    bool HaveNetStartTime;
    NET_TIME NetStartTime;
    TDateTime LocalStopTime;
    bool HaveNetStopTime;
    NET_TIME NetStopTime;
  };
  struct TTriggerAlarmResult : public TTriggerAlarmResultBase
  {
    String TheoricNetFileName;
 
    String SetTheoricNetFileTime(const NET_TIME &AStartTime, const NET_TIME &AEndTime);
    static bool IsTheoricNetFile(const String AFileName, /*out*/NET_TIME &AStartTime, /*out*/NET_TIME &AEndTime);
  };
 
private:
  // Membres Privés
  TNotifyEvent FOnStartProgress;
 
  // Générateurs d'Evènement
  void __fastcall DoStartProgress();
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientTrigger(TSliteDVRDahuaTechnologyClient *AClient);
 
  // Méthodes Publiques
  TTriggerAlarmResult StartNetAlarm(TChannelID AChannelID, TSeconds AExpectedPreTrigger, TSeconds AExpectedPostTrigger, TSeconds ATriggerDuration, TTriggerAlarmOptions* AAlarmOptions = NULL);
  TTriggerAlarmResult& StopNetAlarm(TTriggerAlarmResult &AlarmContext);
  TTriggerAlarmResult& AbortNetAlarm(TTriggerAlarmResult &AlarmContext);
 
  __property TNotifyEvent OnStartProgress = {read=FOnStartProgress, write=FOnStartProgress};
};
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientDownloaderStepEvent            -
//---------------------------------------------------------------------------
typedef void __fastcall (__closure *TSliteDVRDahuaTechnologyClientDownloaderStepEvent)(TSliteDVRDahuaTechnologyClientDownloader* Sender, TSliteDVRDahuaTechnologyClientDownloaderStep AStep);
 
//---------------------------------------------------------------------------
//               TSliteDVRDahuaTechnologyClientDownloaderStep               -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyClientDownloaderStep : Byte
  {dhcdsStart, dhcdsProgress, dhcdsEnd, dhcdsAbort};
 
//---------------------------------------------------------------------------
//                 TSliteDVRDahuaTechnologyClientDownloader                 -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientDownloader [[final]] : public TSliteDVRDahuaTechnologyClientChannelObject
{
  typedef TSliteDVRDahuaTechnologyClientChannelObject inherited;
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientAVIConverter* FAVIConverter;
  TSliteDVRDahuaTechnologyClientDownloaderStepEvent FOnDownloadStep;
 
  DHString FTemporaryDownloadFileName;
  DHString FCurrentDownloadFileName;
  DHString FFinalDownloadFileName;
 
  bool FSavingByConverter;
  bool FSavingByDownload;
  bool FSavingByDifferedConverter;
  bool FSavingByDifferedConverterKeepTemporary;
  LONG FFileID;
  DWORD FTotalSize;
  DWORD FDownloadSize;
 
  // Méthodes Privées
  void TreatConnectionLost();
  __int64 GetCurrentDirectRecordFileSize();
 
  // faire TSliteDVRDahuaTechnologyClientConfigurator::GetPreTriggerSeconds
  // faire TSliteDVRDahuaTechnologyClientConfigurator::GetPostTriggerSeconds
 
  // CallBack
  friend void CALLBACK ClientDownloaderByTimePosCallBack(LONG lPlayHandle, DWORD dwTotalSize, DWORD dwDownLoadSize, int index, NET_RECORDFILE_INFO recordfileinfo, DWORD dwUser);
  void NotifyDownloadStep(LONG lPlayHandle, DWORD dwTotalSize, DWORD dwDownLoadSize);
 
  // Méthodes Privées (Déclenchement et Gestionnaire d'Evènement)
  void DoDownloadStep(TSliteDVRDahuaTechnologyClientDownloaderStep AStep);
  void __fastcall AVIConverterStepEventHandler(TSliteDVRDahuaTechnologyClientAVIConverter* Sender, TSliteDVRDahuaTechnologyClientAVIConverterStep AStep, const __int64 APosition, const __int64 ASize);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientDownloader(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientDownloader();
 
  bool StartDownloadByDateTime(const TDateTime &AStartTime, const TDateTime &AEndTime, const TFileName AVideoFileName, TSliteDVRDahuaTechnologyClientLocalFileType AFileType, bool AKeepTemporary);
  bool StopDownloadByDateTime(bool Forced = false);
 
  // Propriétés Publiques
  __property DHString CurrentDownloadFileName = {read=FCurrentDownloadFileName};
  __property DHString FinalDownloadFileName = {read=FFinalDownloadFileName};
  __property TSliteDVRDahuaTechnologyClientDownloaderStepEvent OnDownloadStep = {read=FOnDownloadStep, write=FOnDownloadStep};
};
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientAVIConverterThread             -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientAVIConverterThread : public TThread
{
  typedef TThread inherited;
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientAVIConverter* FConverter;
  struct TBuffer
  {
    BYTE *Data;
    DWORD Size;
    TBuffer* Next;
    bool Final;
 
    TBuffer() : Data(NULL), Size(0), Next(NULL), Final(false) {}
  };
  struct TBufferList
  {
    TBuffer* First;
    TBuffer* Last;
    TCriticalSection* Lock; // Géré en RAII
 
    TBufferList() : First(NULL), Last(NULL), Lock(new TCriticalSection()) {}
    ~TBufferList() {delete Lock; Lock = NULL;}
  };
  TBufferList FWaitingList;
  bool FAborted;
 
  // Méthodes Privées
  TSliteDVRDahuaTechnologyClientAVIConverterThread::TBuffer* NextData(TBuffer* Item);
 
protected:
  // Méthodes Protégées Redéfinies (TThread)
  /*override*/virtual void __fastcall Execute(void);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientAVIConverterThread(TSliteDVRDahuaTechnologyClientAVIConverter* AConverter);
 
  // Méthodes Publiques
  bool AddData(BYTE *Buffer, DWORD Bufsize, bool Final = false);
  bool AddEnd();
  bool StopConvert(bool Forced = false);
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientAVIConverter                -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientAVIConverter : public TObject
{
  friend /*method*/ void __fastcall TSliteDVRDahuaTechnologyClientAVIConverterThread::Execute(void);
 
private:
  // Membres Privés
  LONG FPort;
  BOOL FOpened;
  BOOL FPlaying;
  BOOL FConverting;
  DHString FAVIFileName;
  int MediaChangeCount;
  DWORD FDHLastError;
  __int64 FTheoricSize;
 
  // CallBack
  friend void __stdcall AVIConvertMediaChangeCallback(long nPort, long lMediaChangeType, long lUser, BOOL *pbIfContinue, char *sNewFileName);
  void NotifyMediaChangeCallBack(long nPort, long lMediaChangeType, BOOL *pbIfContinue, char *sNewFileName);
 
protected:
  // Membres Protégés
  TSliteDVRDahuaTechnologyClientAVIConverterThread* FConverterThread;
  TSliteDVRDahuaTechnologyClientAVIConverterStepEvent FOnConvertStep;
 
  // Méthodes Protégées (Déclenchement d'Evènement)
  virtual void DoConvertStep(TSliteDVRDahuaTechnologyClientAVIConverterStep AStep, const __int64 APosition, const __int64 ASize);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientAVIConverter(const DHString ADestinationFileName);
 
  // Méthodes Publiques
  virtual bool Start();
  virtual bool Stop(bool Forced = false);
 
  // Propriétés Publiques
  __property LONG Port = {read=FPort};
  __property DHString AVIFileName = {read=FAVIFileName};
  __property DWORD DHLastError = {read=FDHLastError};
  __property TSliteDVRDahuaTechnologyClientAVIConverterStepEvent OnConvertStep = {read=FOnConvertStep, write=FOnConvertStep};
};
 
//---------------------------------------------------------------------------
//        TSliteDVRDahuaTechnologyClientAVIConverterFromMonitorStream       -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientAVIConverterFromMonitorStream [[final]] : public TSliteDVRDahuaTechnologyClientAVIConverter
{
  typedef TSliteDVRDahuaTechnologyClientAVIConverter inherited;
  friend void CALLBACK AVIConverterRealDataCallBack(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize, DWORD dwUser);
 
private:
  // Membres Privés
  LONG FMonitorID;
 
  bool FCallBackRealData;
  bool FIncoherentCallBack;
 
  // Méthodes Privées
  void NotifyRealDataCallBack(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientAVIConverterFromMonitorStream(LONG AMonitorID, const TFileName ADestinationFileName);
 
  // Constructeurs Publiques
  /*override*/virtual bool Start();
  /*override*/virtual bool Stop(bool Forced = false);
 
  // Propriétés Publiques
  __property LONG MonitorID = {read=FMonitorID};
};
 
//---------------------------------------------------------------------------
//        TSliteDVRDahuaTechnologyClientAVIConverterFromFileThread          -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientAVIConverterFromFileThread : public TThread
{
  typedef TThread inherited;
 
private:
  // Membres Privés
  TSliteDVRDahuaTechnologyClientAVIConverterFromFile* FConverter;
  TSliteDVRDahuaTechnologyClientAVIConverterThread* FConverterThread;
  TFileName FSourceFileName;
  __int64 FSourceFileSize;
  bool FAborted;
 
protected:
  // Méthodes Protégées Redéfinies (TThread)
  /*override*/virtual void __fastcall Execute(void);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientAVIConverterFromFileThread(TSliteDVRDahuaTechnologyClientAVIConverterFromFile* AConverter, const TFileName ASourceFileName, TSliteDVRDahuaTechnologyClientAVIConverterThread* AConverterThread);
 
  // Méthodes Publiques
  bool StopConvert(bool Forced = false);
 
  // Propriétés Publiques
  __property __int64 SourceFileSize = {read=FSourceFileSize};
};
 
//---------------------------------------------------------------------------
//            TSliteDVRDahuaTechnologyClientAVIConverterFromFile            -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientAVIConverterFromFile [[final]] : public TSliteDVRDahuaTechnologyClientAVIConverter
{
  typedef TSliteDVRDahuaTechnologyClientAVIConverter inherited;
  friend /*method*/ void __fastcall TSliteDVRDahuaTechnologyClientAVIConverterFromFileThread::Execute(void);
 
private:
  // Membres Privés
  TFileName FSourceFileName;
  __int64 FSourceFileSize;
  TSliteDVRDahuaTechnologyClientAVIConverterFromFileThread* FReaderThread;
 
protected:
  // Méthodes Protégées (Déclenchement d'Evènement)
  /*override*/virtual void DoConvertStep(TSliteDVRDahuaTechnologyClientAVIConverterStep AStep, const __int64 APosition, const __int64 ASize);
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientAVIConverterFromFile(const TFileName ASourceFileName, const TFileName ADestinationFileName);
 
  // Constructeurs Publiques
  /*override*/virtual bool Start();
  /*override*/virtual bool Stop(bool Forced = false);
};
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyTestConnectionDepth               -
//---------------------------------------------------------------------------
// Les Suivants implique leurs Précédents
enum TSliteDVRDahuaTechnologyTestConnectionDepth : Byte
  {dhtcdNone, dhtcdConnection, dhtcdReadState, dhtcdRealPlay, dhtcdStatistics, dhtcdManuallyStatistics, dhtcdEnumCount}; // dhtcdEnumCount doit être la dernière valeur et Ne pas changer l'ordre !
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyTestConnectionResultType             -
//---------------------------------------------------------------------------
enum TSliteDVRDahuaTechnologyTestConnectionResultType : Byte
  {dhtcrSuccess, dhtcrFailure, dhtcrVideoLost, dhtcrNoStream};
 
//---------------------------------------------------------------------------
//             TSliteDVRDahuaTechnologyClientFullyTestConnection            -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientFullyTestConnection [[final]] : public TSliteDVRDahuaTechnologyClientChannelObject
{
  typedef TSliteDVRDahuaTechnologyClientChannelObject inherited;
 
  friend void CALLBACK ClientTestConnectionRealDataCallBack(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize, DWORD dwUser);
 
private:
  // Membres Privés
  int FDataReceivedSize;
  bool FIncoherentCallBack;
  bool FVideoLost;
 
  // Méthodes Privées
  void NotifyRealDataCallBack(LONG lRealHandle, DWORD dwDataType, BYTE *pBuffer, DWORD dwBufsize);
 
  TSliteDVRDahuaTechnologyTestConnectionResultType ReadStatistics(TSliteDVRDahuaTechnologyTestConnectionDepth ADepth);
  TSliteDVRDahuaTechnologyTestConnectionResultType ReadBasicStatistics();
  TSliteDVRDahuaTechnologyTestConnectionResultType ReadManuallyStatistics();
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientFullyTestConnection(TSliteDVRDahuaTechnologyClient *AClient);
  /*destructor*/virtual __fastcall ~TSliteDVRDahuaTechnologyClientFullyTestConnection();
 
  // Méthodes Publiques
  /*override*/virtual bool OpenChannel(TChannelID AChannelID);
 
  // Méthodes Publiques
  TSliteDVRDahuaTechnologyTestConnectionResultType TestConnection(TSliteDVRDahuaTechnologyTestConnectionDepth ADepth);
};
 
//---------------------------------------------------------------------------
//              TSliteDVRDahuaTechnologyClientLazyTestConnection            -
//---------------------------------------------------------------------------
class TSliteDVRDahuaTechnologyClientLazyTestConnection [[final]] : public TSliteDVRDahuaTechnologyClientSessionObject
{
  typedef TSliteDVRDahuaTechnologyClientSessionObject inherited;
  typedef int TChannelID;
 
public:
  // Constructeurs Publiques
  /*constructor*/__fastcall TSliteDVRDahuaTechnologyClientLazyTestConnection(TSliteDVRDahuaTechnologyClient *AClient);
 
  // Méthodes Publiques
  TSliteDVRDahuaTechnologyTestConnectionResultType TestConnection(TSliteDVRDahuaTechnologyTestConnectionDepth ADepth, TChannelID AChannelID);
};
 
 
//---------------------------------------------------------------------------
//                TSliteDVRDahuaTechnologyClientEventListener               -
//---------------------------------------------------------------------------
#pragma option push -w-diu // W8130 L'interface ne dérive pas de IUnknown.
class TSliteDVRDahuaTechnologyClientEventListener [[final]] : public TSliteDVRDahuaTechnologyClientSessionObject,
  public ISliteDVRDahuaTechnologyClientObjectKeeperIneradicable
{
...

**Ouail1825** · 12/06/2016, 00h46

merci pour ta réponse Mr, tu es vraiment très aimable.

gérer tes Handle de périphérique, la clé est là, tout est dans ces handles

concernant la notion de classe tu vien de me donner une grande piste dont je te remercie bcp.
donc je doi créer une classe exemple: TAccessControl qui est un TObject, j'ai créer quelques propriétés dont j'ai jugé utiles jusqu'à présent

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
///////////////////////////////////////////////////////////////////////////////
//                 Création d'une classe TAccessControl                     //
//////////////////////////////////////////////////////////////////////////////
 
unit PanelC3;
 
interface
uses
  System.SysUtils, System.Variants;
 
type
  TAccessControl = class(TObject)
    private
     aprotocole,IP    : String;
     aAlias           : WideString;
     MNumb,aport,TOut : Integer;
     Connecter        : Boolean;
 
     Function  GetConnecter : Boolean;
     Procedure SetConnecter (Value : Boolean);
 
     Function  GetProtocole : String;
     Procedure SetProtocole (Value : String);
 
     Function  GetIP : String;
     Procedure SetIP (Value : String);
 
     Function  GetPort : Integer;
     Procedure SetPort(Value : Integer);
 
     Function  GetTOut : Integer;
     Procedure SetTOut (Value : Integer);
 
     Function  GetAlias : WideString;
     Procedure SetAlias (Value :WideString);
 
     Function  GetMNumb : Integer;
     Procedure SetMNumb (Value : Integer);
 
    public
     constructor Create;
 
     Property protocole        : String      read Getprotocole  write Setprotocole;
     Property ipadresse        : String      read GetIP         write SetIP ;
     Property port             : Integer     read GetPort       write SetPort  ;
     Property timeout          : Integer     read GetTOut       write SetTOut ;
     Property Alias            : WideString  read GetAlias      write SetAlias ;
     Property MachineNumber    : Integer     read GetMNumb      write SetMNumb ;
     Property Connected        : Boolean     read GetConnecter  write SetConnecter;
 
  end;
 
 
implementation
 
constructor TAccessControl.Create;
begin
  protocole     := 'TCP';
  ipadresse     := '192.168.1.201';
  port          := 4370;
  timeout       := 4000;
  MachineNumber := 1;
  Alias         := 'Machine';
  Connected     := False;
end;
 
function TAccessControl.GetProtocole: String;
begin
  Result := aProtocole;
end;
 
procedure TAccessControl.SetProtocole(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      aProtocole := Value;
    end
  else aProtocole :='TCP';
end;
 
function TAccessControl.GetIP: String;
begin
  Result := aProtocole;
end;
 
procedure TAccessControl.SetIP(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      IP := Value;
    end
  else IP :='192.168.1.201';
end;
 
function TAccessControl.GetAlias: WideString;
begin
  Result := aAlias;
end;
 
procedure TAccessControl.SetAlias(Value: WideString);
begin
  if Trim(Value) <> EMptyStr then
    begin
      aAlias := Value;
    end
  else aAlias :='Machine';
end;
 
function TAccessControl.GetPort: Integer;
begin
  Result := aPort;
end;
 
procedure TAccessControl.SetPort(Value: Integer);
begin
  if Value > 0 then
    begin
      aPort := Value;
    end
  else aPort := 4370;
end;
 
function TAccessControl.GetTOut: Integer;
begin
  Result := aPort;
end;
 
procedure TAccessControl.SetTout(Value: Integer);
begin
  if Value > 0 then
    begin
      TOut := Value;
    end
  else TOut := 4000;
end;
 
function TAccessControl.GetMNumb: Integer;
begin
  Result := MNumb;
end;
 
procedure TAccessControl.SetMNumb(Value: Integer);
begin
  if Value > 0 then
    begin
      MNumb := Value;
    end
  else MNumb := 1;
end;
 
function TAccessControl.GetConnecter: Boolean;
begin
  Result := Connecter;
end;
 
procedure TAccessControl.SetConnecter(Value: Boolean);
begin
  if Value <> Null then
    begin
      Connecter := Value;
    end
  else Connecter :=False;
end;
end.

cette classe va porter les actions voulus, celles que j'ai déjà cité (Connect, disconnect,SetDeviceParam,GetDeviceParam ..) c'est ça?
le problème est que c'est méthodes (Functions / Procédures), sont dans une DLL dont je fais appel, donc je ne trouve pas comment les implémenter dans cette unité? en plus l'ajout du: external 'plcommpro.dll'; déclanche une excéption Définition de champ non autorisée après des méthodes ou propriétés.??
merci d'avance

**ShaiLeTroll** · 13/06/2016, 09h15

Tu devrais une faire une 1ère unité : UnitDLL (je te laisse choisir un nom qui te plaira)
soit en external
soit LoadLibrary\GetProcAddress, cela ne rendra pas ton code dépendant de la DLL

Ta classe, tu l'as mets dans une AUTRE unité UnitPOO
la 1ère unité n'étant inclu que dans la partie implementation\uses

Ton objet est une sorte de Proxy, il ne fait qu'exposer dans méthodes et en interne il invoque une ou plusieurs fonctions de la DLL

Petit conseil, préfixe les membre privés des propriétés (champs <-> Fields)
Réserve le A pour Arguments pour les paramètres des fonctions

Code :

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

1
2
3
4
5
6
7
8
type
  TAccessControl = class(TObject)
    private
     FProtocole, FIP    : String;
     FAlias           : WideString;
     FMNumb,Fport,FTOut : Integer;
     FConnected        : Boolean;
     FHandle: THandle; // Ne l'oublie pas celui là !

Partons sur

Code :

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

1
2
 
 Property Connected        : Boolean     read GetConnected  write SetConnected

Voici un exemple théorique du code

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
function TAccessControl.GetConnected: Boolean;
begin
  Result := FConnected;
end;
 
procedure TAccessControl.SetConnected(Value: Boolean);
begin
  if Value then // ne compare pas un Boolean avec Null qui est de type Variant
  begin
    FHandle := UnitDLL.Connect(PChar(' ... Bla bla bla ... ')): // je te conseille de faire une méthode MakeConnectParameters qui retourne la concaténation des paramètres, la fonction Format serait idéal pour l'écrire !
    FConnected := FHandle  > 0;
  end
  else 
  begin
    FConnected := False;
    Disconnect(FHandle);
    FHandle := 0;
  end;
end;

**Ouail1825** · 14/06/2016, 04h09

ShaiLeTroll tu es vraiment un

Ok j'ai créé une unité UnitDLL

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
 
unit UnitDll;
 
interface
 uses
  Winapi.Windows,
  System.SysUtils,
  Vcl.Dialogs;
 
  Procedure LoadDll;
 
  function  Connect        (Parameters: PChar): THandle; StdCall; external 'plcommpro.dll';
  Procedure Disconnect     (HandleDLL:THandle);StdCall; external 'plcommpro.dll';
  function  PullLastError  ():Integer;StdCall; external 'plcommpro.dll';
  function  SetDeviceParam (Han : THandle; ItemValues:PChar):Integer;StdCall; external 'plcommpro.dll';
  function  GetDeviceParam (Han : THandle; Var Buffer:Byte; BufferSize: Integer;
                          ItemValues:PChar):Integer;StdCall; external 'plcommpro.dll';
  function  ControlDevice  (Han : THandle; operationid: Integer; param1,
                           param2, param3, param4 : Integer; options: PChar): Integer; StdCall; external 'plcommpro.dll';
  function  SetDeviceData  (Han : THandle; tablename, data, options:PChar): Integer;StdCall; external 'plcommpro.dll';
  function  GetDeviceData  (Han : THandle; buffer:Byte; buffersize:Integer;
                           tablename, filename, filter,Option :PChar):Integer;StdCall; external 'plcommpro.dll';
  function  GetDeviceDataCount  (Han : THandle; tablename,filter,options: PChar ): Integer;StdCall; external 'plcommpro.dll';
  function  DeleteDeviceData    (Han : THandle; tablename, data, options:PChar): Integer;StdCall; external 'plcommpro.dll';
  function  GetRTLog            (Han : THandle; Var buffer; buffersize:Integer): Integer;StdCall; external 'plcommpro.dll';
  function  SearchDevice        (commtype, address:PChar; buffer: Byte): Integer;StdCall; external 'plcommpro.dll';
  function  ModifyIPAddress     (commtype, address, buffer: PChar): Integer;StdCall; external 'plcommpro.dll';
 
  function  SetDeviceFileData   (Han : THandle; filename:PChar; Var buffer;
                               buffersize:Integer; options:PChar): Integer;StdCall; external 'plcommpro.dll';
  function  GetDeviceFileData   (Han : THandle; Var buffer; buffersize:integer;
                               filename, options:PChar):integer;StdCall; external 'plcommpro.dll';
  function  ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;StdCall; external 'plcommpro.dll';
 
  Var
  NomDll:String;
  HandleDLL:THandle;
 
implementation
 
 
procedure LoadDll ;
begin
  NomDll:='plcommpro.dll';
  HandleDLL:=LoadLibrary(PChar(NomDll));
  if HandleDLL = 0 then
   Begin
    ShowMessage('erreur chargement de la DLL');
    Exit;
   End;
end;
end.

aussi une autre autre unité portant la classe TAccessControl, mais j'ai dû changé la classe de TObject à (TControl), car j'ai besoin de l'attribut Nom du control, afin de pouvoir l'identifié

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
///////////////////////////////////////////////////////////////////////////////
//                 Création d'une classe TAccessControl                     //
//////////////////////////////////////////////////////////////////////////////
 
unit PanelC3;
 
interface
uses
  System.SysUtils, System.Variants,Vcl.Dialogs,Vcl.Controls,System.Classes,WinApi.Windows;
 
type
  TAccessControl = class(TControl)
    private
     FProtocole,FIP     : String;
     FAlias             : WideString;
     FMNumb,Fport,FTOut : Integer;
     FConnected         : Boolean;
     FHandle            : THandle;
 
     Function  GetConnected : Boolean;
     Procedure SetConnected (Value : Boolean);
 
     Function  GetProtocole : String;
     Procedure SetProtocole (Value : String);
 
     Function  GetIP : String;
     Procedure SetIP (Value : String);
 
     Function  GetPort : Integer;
     Procedure SetPort(Value : Integer);
 
     Function  GetTOut : Integer;
     Procedure SetTOut (Value : Integer);
 
     Function  GetAlias : WideString;
     Procedure SetAlias (Value :WideString);
 
     Function  GetMNumb : Integer;
     Procedure SetMNumb (Value : Integer);
 
    public
     constructor Create (AOwner:TObject);
 
     Property protocole        : String      read Getprotocole  write Setprotocole;
     Property ipadresse        : String      read GetIP         write SetIP ;
     Property port             : Integer     read GetPort       write SetPort  ;
     Property timeout          : Integer     read GetTOut       write SetTOut ;
     Property Alias            : WideString  read GetAlias      write SetAlias ;
     Property MachineNumber    : Integer     read GetMNumb      write SetMNumb ;
     Property Connected        : Boolean     read GetConnected  write SetConnected;
 
     Function  Connect        (Parameters: PChar): THandle;
     Procedure Disconnect     (HandleDLL:THandle);
     Function  PullLastError  ():Integer;
     Function  SetDeviceParam (Han : THandle; ItemValues:PChar):Integer;
     Function  GetDeviceParam (Han : THandle; Var Buffer:Byte; BufferSize: Integer;
                               ItemValues:PChar):Integer;
     Function  ControlDevice  (Han : THandle; operationid: Integer; param1,
                               param2, param3, param4 : Integer; options: PChar): Integer;
     Function  SetDeviceData  (Han : THandle; tablename, data, options:PChar): Integer;
     Function  GetDeviceData  (Han : THandle; buffer:Byte; buffersize:Integer;
                               tablename, filename, filter,Option :PChar):Integer;
     Function  GetDeviceDataCount  (Han : THandle; tablename,filter,options: PChar ): Integer;
     Function  DeleteDeviceData    (Han : THandle; tablename, data, options:PChar): Integer;
     Function  GetRTLog            (Han : THandle; Var buffer; buffersize:Integer): Integer;
     Function  SearchDevice        (commtype, address:PChar; buffer: Byte): Integer;
     Function  ModifyIPAddress     (commtype, address, buffer: PChar): Integer;
 
     Function  SetDeviceFileData   (Han : THandle; filename:PChar; Var buffer;
                                    buffersize:Integer; options:PChar): Integer;
     Function  GetDeviceFileData   (Han : THandle; Var buffer; buffersize:integer;
                                    filename, options:PChar):integer;
     Function  ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;
  end;
 
 
implementation
Uses UnitDll;
 
constructor TAccessControl.Create(AOwner:TObject);
begin
 UnitDll.LoadDll;
 protocole     := 'TCP';
 ipadresse     := '192.168.1.201';
 port          := 4370;
 timeout       := 4000;
 MachineNumber := 1;
 Alias         := 'Machine';
 Connected     := False;
end;
 
 
function TAccessControl.GetProtocole: String;
begin
  Result := FProtocole;
end;
 
procedure TAccessControl.SetProtocole(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FProtocole := Value;
    end
  else FProtocole :='TCP';
end;
 
function TAccessControl.GetIP: String;
begin
  Result := FIP;
end;
 
procedure TAccessControl.SetIP(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FIP := Value;
    end
  else FIP :='192.168.1.201';
end;
 
function TAccessControl.GetAlias: WideString;
begin
  Result := FAlias;
end;
 
procedure TAccessControl.SetAlias(Value: WideString);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FAlias := Value;
    end
  else FAlias :='Machine';
end;
 
function TAccessControl.GetPort: Integer;
begin
  Result := FPort;
end;
 
procedure TAccessControl.SetPort(Value: Integer);
begin
  if Value > 0 then
    begin
      FPort := Value;
    end
  else FPort := 4370;
end;
 
function TAccessControl.GetTOut: Integer;
begin
  Result := FTOut;
end;
 
procedure TAccessControl.SetTout(Value: Integer);
begin
  if Value > 0 then
    begin
      FTOut := Value;
    end
  else FTOut := 4000;
end;
 
function TAccessControl.GetMNumb: Integer;
begin
  Result := FMNumb;
end;
 
procedure TAccessControl.SetMNumb(Value: Integer);
begin
  if Value > 0 then
    begin
      FMNumb := Value;
    end
  else FMNumb := 1;
end;
 
function TAccessControl.GetConnected: Boolean;
begin
  Result := FConnected;
end;
 
procedure TAccessControl.SetConnected(Value: Boolean);
Var Adr : String; Str : PChar;
begin
  Adr := protocole+ipadresse+Port.ToString+Timeout.ToString ;
  if Value then
  begin
    FHandle := UnitDLL.Connect(PChar(Adr));
    FConnected := FHandle  > 0;
  end
  else
  begin
    FConnected := False;
    Disconnect(FHandle);
    FHandle := 0;
  end;
end;
 
Function TAccessControl.Connect(Parameters: PWideChar):THandle;
begin
 
end;
 
Procedure TAccessControl.Disconnect (HandleDLL:THandle);
Begin
 UnitDll.Disconnect(FHandle);
End;
 
Function TAccessControl.PullLastError():Integer;
Begin
 FHandle := UnitDll.PullLastError ;
End;
 
Function TAccessControl.SetDeviceParam (Han : THandle; ItemValues:PChar):Integer;
Begin
 FHandle := UnitDll.SetDeviceParam(Han,ITemValues);
End;
 
Function TAccessControl.GetDeviceParam (Han : THandle; Var Buffer:Byte; BufferSize: Integer; ItemValues:PChar):Integer;
Begin
 FHandle := UnitDll.GetDeviceParam (Han , Buffer, BufferSize, ItemValues);
End;
 
Function TAccessControl.ControlDevice  (Han : THandle; operationid: Integer; param1,
    param2, param3, param4 : Integer; options: PChar): Integer;
Begin
 FHandle := UnitDll.ControlDevice  (Han, operationid, param1,
    param2, param3, param4, options);
End;
 
Function TAccessControl.SetDeviceData  (Han : THandle; tablename, data, options:PChar): Integer;
Begin
 FHandle := UnitDll.SetDeviceData  (Han, tablename, data, options);
End;
 
Function TAccessControl.GetDeviceData  (Han : THandle; buffer:Byte; buffersize:Integer;
    tablename, filename, filter,Option:PChar):Integer;
Begin
 FHandle := UnitDll.GetDeviceData  (Han, buffer, buffersize,tablename, filename, filter,Option);
End;
 
Function TAccessControl.GetDeviceDataCount  (Han : THandle; tablename,filter,options: PChar ): Integer;
Begin
 FHandle := UnitDll.GetDeviceDataCount  (Han, tablename,filter,options);
End;
 
Function TAccessControl.DeleteDeviceData    (Han : THandle; tablename, data, options:PChar): Integer;
Begin
 FHandle := UnitDll.DeleteDeviceData    (Han , tablename, data, options);
End;
 
Function TAccessControl.GetRTLog  (Han : THandle; Var buffer; buffersize:Integer): Integer;
Begin
 FHandle := UnitDll.GetRTLog  (Han,buffer, buffersize);
End;
 
Function TAccessControl.SearchDevice   (commtype, address:PChar; buffer: Byte): Integer;
Begin
 FHandle := UnitDll.SearchDevice   (commtype, address,buffer);
End;
 
Function TAccessControl.ModifyIPAddress(commtype, address, buffer: PChar): Integer;
Begin
 FHandle := UnitDll.ModifyIPAddress(commtype, address, buffer);
End;
 
Function TAccessControl.SetDeviceFileData (Han : THandle; filename:PChar; Var buffer;
                             buffersize:Integer; options:PChar): Integer;
Begin
 FHandle := UnitDll.SetDeviceFileData (Han,filename,buffer,buffersize,options);
End;
 
Function TAccessControl.GetDeviceFileData   (Han : THandle; Var buffer; buffersize:integer;
filename, options:PChar):integer;
Begin
 FHandle := UnitDll.GetDeviceFileData   (Han, buffer, buffersize,filename, options);
End;
 
Function TAccessControl.ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;
Begin
 FHandle := UnitDll.ProcessBackupData   (Data,fileLen,Buffer,BufferSize);
End;
end.

tu trouveras ci-joint, un petit exemple d'utilisation, qui comporte un problème de détection du control créer dynamiquement.

**ShaiLeTroll** · 14/06/2016, 10h47

C'est logique, tu oublies d'utiliser FHandle !
Retire tous les Han : THandle; comme paramètre de l'objet TAccessControl

Et surtout retire TOUTES modifications de FHandle hors du SetConnected
FHandle est la seule chose a être vraiment importante dans l'encapsulation par TAccessControl

Tu ne dois JAMAIS manipulé le FHandle depuis l'extérieur de l'objet TAccessControl, c'est le principe de l'encaspulation et au vu de ton rar, tu as toujours du mal avec ça !

TControl c'est un composant visuel, tu aurais du utiliser une TStringList ou un TObjectDictionnary, ces deux listes permettent d'associer un nom avec un objet
Cela aurait été plus propre qu'un FindComponent

Je te conseille aussi de pousser l'encapsulation en utilisant du string comme paramètres des méthodes de TAccessControl à la place du PChar
C'est TAccessControl qui assure le passage entre string et PChar, ainsi l'objet TAccessControl est plus convivial d'utilisation

TAccessControl est là pour faire les choses pénibles ou compliqués pour que le code autour soit ultra simple et lisible

J'ai fait un remplacer par Notepad++ de la mauvaise utilisation de FHandle
J'ai retiré Connect et Disconnect qui sont encapsulé par la propriété Connected qu'il suffit de passer à True pour se connecter

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
///////////////////////////////////////////////////////////////////////////////
//                 Création d'une classe TAccessControl                     //
//////////////////////////////////////////////////////////////////////////////
 
unit PanelC3;
 
interface
uses
  System.SysUtils, System.Variants,Vcl.Dialogs,Vcl.Controls,System.Classes,WinApi.Windows;
 
type
  TAccessControl = class(TControl)
    private
     FProtocole,FIP     : String;
     FAlias             : WideString;
     FMNumb,Fport,FTOut : Integer;
     FConnected         : Boolean;
     FHandle            : THandle;
 
     Function  GetConnected : Boolean;
     Procedure SetConnected (Value : Boolean);
 
     Function  GetProtocole : String;
     Procedure SetProtocole (Value : String);
 
     Function  GetIP : String;
     Procedure SetIP (Value : String);
 
     Function  GetPort : Integer;
     Procedure SetPort(Value : Integer);
 
     Function  GetTOut : Integer;
     Procedure SetTOut (Value : Integer);
 
     Function  GetAlias : WideString;
     Procedure SetAlias (Value :WideString);
 
     Function  GetMNumb : Integer;
     Procedure SetMNumb (Value : Integer);
 
    public
     constructor Create (AOwner:TObject);
 
     Property protocole        : String      read Getprotocole  write Setprotocole;
     Property ipadresse        : String      read GetIP         write SetIP ;
     Property port             : Integer     read GetPort       write SetPort  ;
     Property timeout          : Integer     read GetTOut       write SetTOut ;
     Property Alias            : WideString  read GetAlias      write SetAlias ;
     Property MachineNumber    : Integer     read GetMNumb      write SetMNumb ;
     Property Connected        : Boolean     read GetConnected  write SetConnected;
 
     Function  PullLastError  ():Integer;
     Function  SetDeviceParam (ItemValues:PChar):Integer;
     Function  GetDeviceParam (Var Buffer:Byte; BufferSize: Integer;
                               ItemValues:PChar):Integer;
     Function  ControlDevice  (operationid: Integer; param1,
                               param2, param3, param4 : Integer; options: PChar): Integer;
     Function  SetDeviceData  (tablename, data, options:PChar): Integer;
     Function  GetDeviceData  (buffer:Byte; buffersize:Integer;
                               tablename, filename, filter,Option :PChar):Integer;
     Function  GetDeviceDataCount  (tablename,filter,options: PChar ): Integer;
     Function  DeleteDeviceData    (tablename, data, options:PChar): Integer;
     Function  GetRTLog            (Var buffer; buffersize:Integer): Integer;
     Function  SearchDevice        (commtype, address:PChar; buffer: Byte): Integer;
     Function  ModifyIPAddress     (commtype, address, buffer: PChar): Integer;
 
     Function  SetDeviceFileData   (filename:PChar; Var buffer;
                                    buffersize:Integer; options:PChar): Integer;
     Function  GetDeviceFileData   (Var buffer; buffersize:integer;
                                    filename, options:PChar):integer;
     Function  ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;
  end;
 
 
implementation
Uses UnitDll;
 
constructor TAccessControl.Create(AOwner:TObject);
begin
 UnitDll.LoadDll;
 protocole     := 'TCP';
 ipadresse     := '192.168.1.201';
 port          := 4370;
 timeout       := 4000;
 MachineNumber := 1;
 Alias         := 'Machine';
end;
 
 
function TAccessControl.GetProtocole: String;
begin
  Result := FProtocole;
end;
 
procedure TAccessControl.SetProtocole(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FProtocole := Value;
    end
  else FProtocole :='TCP';
end;
 
function TAccessControl.GetIP: String;
begin
  Result := FIP;
end;
 
procedure TAccessControl.SetIP(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FIP := Value;
    end
  else FIP :='192.168.1.201';
end;
 
function TAccessControl.GetAlias: WideString;
begin
  Result := FAlias;
end;
 
procedure TAccessControl.SetAlias(Value: WideString);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FAlias := Value;
    end
  else FAlias :='Machine';
end;
 
function TAccessControl.GetPort: Integer;
begin
  Result := FPort;
end;
 
procedure TAccessControl.SetPort(Value: Integer);
begin
  if Value > 0 then
    begin
      FPort := Value;
    end
  else FPort := 4370;
end;
 
function TAccessControl.GetTOut: Integer;
begin
  Result := FTOut;
end;
 
procedure TAccessControl.SetTout(Value: Integer);
begin
  if Value > 0 then
    begin
      FTOut := Value;
    end
  else FTOut := 4000;
end;
 
function TAccessControl.GetMNumb: Integer;
begin
  Result := FMNumb;
end;
 
procedure TAccessControl.SetMNumb(Value: Integer);
begin
  if Value > 0 then
    begin
      FMNumb := Value;
    end
  else FMNumb := 1;
end;
 
function TAccessControl.GetConnected: Boolean;
begin
  Result := FConnected;
end;
 
procedure TAccessControl.SetConnected(Value: Boolean);
Var Adr : String; Str : PChar;
begin
  Adr := protocole+ipadresse+Port.ToString+Timeout.ToString ;
  if Value then
  begin
     FHandle := UnitDLL.Connect(PChar(Adr));
     FConnected := FHandle  > 0;
  end
  else
  begin
     FConnected := False;
     UnitDLL.Disconnect(FHandle);
     FHandle  := 0;
  end;
end;
 
 
Function TAccessControl.PullLastError():Integer;
Begin
 Result := UnitDll.PullLastError ;
End;
 
Function TAccessControl.SetDeviceParam (ItemValues:PChar):Integer;
Begin
 Result := UnitDll.SetDeviceParam(FHandle, ITemValues);
End;
 
Function TAccessControl.GetDeviceParam (Var Buffer:Byte; BufferSize: Integer; ItemValues:PChar):Integer;
Begin
  Result := UnitDll.GetDeviceParam (FHandle,  Buffer, BufferSize, ItemValues);
End;
 
Function TAccessControl.ControlDevice  (operationid: Integer; param1,
    param2, param3, param4 : Integer; options: PChar): Integer;
Begin
  Result := UnitDll.ControlDevice  (FHandle,  operationid, param1,
    param2, param3, param4, options);
End;
 
Function TAccessControl.SetDeviceData  (tablename, data, options:PChar): Integer;
Begin
  Result := UnitDll.SetDeviceData  (FHandle,  tablename, data, options);
End;
 
Function TAccessControl.GetDeviceData  (buffer:Byte; buffersize:Integer;
    tablename, filename, filter,Option:PChar):Integer;
Begin
  Result := UnitDll.GetDeviceData  (FHandle,  buffer, buffersize,tablename, filename, filter,Option);
End;
 
Function TAccessControl.GetDeviceDataCount  (tablename,filter,options: PChar ): Integer;
Begin
  Result := UnitDll.GetDeviceDataCount  (FHandle,  tablename,filter,options);
End;
 
Function TAccessControl.DeleteDeviceData    (tablename, data, options:PChar): Integer;
Begin
  Result := UnitDll.DeleteDeviceData    (FHandle,  tablename, data, options);
End;
 
Function TAccessControl.GetRTLog  (Var buffer; buffersize:Integer): Integer;
Begin
  Result := UnitDll.GetRTLog  (FHandle, buffer, buffersize);
End;
 
Function TAccessControl.SearchDevice   (commtype, address:PChar; buffer: Byte): Integer;
Begin
  Result := UnitDll.SearchDevice   (commtype, address,buffer);
End;
 
Function TAccessControl.ModifyIPAddress(commtype, address, buffer: PChar): Integer;
Begin
  Result := UnitDll.ModifyIPAddress(commtype, address, buffer);
End;
 
Function TAccessControl.SetDeviceFileData (filename:PChar; Var buffer;
                             buffersize:Integer; options:PChar): Integer;
Begin
  Result := UnitDll.SetDeviceFileData (FHandle, filename,buffer,buffersize,options);
End;
 
Function TAccessControl.GetDeviceFileData   (Var buffer; buffersize:integer;
filename, options:PChar):integer;
Begin
  Result := UnitDll.GetDeviceFileData   (FHandle,  buffer, buffersize,filename, options);
End;
 
Function TAccessControl.ProcessBackupData   (Data: Array of Byte; fileLen: Integer; Var Buffer; BufferSize:Integer):Integer;
Begin
  Result := UnitDll.ProcessBackupData   (Data,fileLen,Buffer,BufferSize);
End;
end.

**Ouail1825** · 23/06/2016, 02h21

excuse de ne pas avoir répondu pendant ce temps, j'ai eu un accident de la circulation un peut critique

je me retire quelque temps pour me rétablir, sinon vos observations sont prises en considération, je vous feraai part des modifications dès que possible.
pour la conversion du pchar en string c'est fait, mais l'utilisation d'un TObjectDictionnary ou d'un tstringlist pour répertorier les object créer dynamiquement j'ai pas su comment faire.
je pense que c'est ça la cause de mon accident car j'y pensais en conduisant

merci pour votre aide, Mr .. vous êtes vraiment très aimable vous et toute l'équipe du http://www.developpez.net/ qui veille sur le forum

**Ouail1825** · 03/07/2016, 20h07

Salut ShaiLeTroll;
de retour après rétablissement,
j'ai profiter de mon CM, pour faire quelques changements dans le code, j'ai éliminer l'unité dll, et j'ai fusionné les deux unités en une seule,
aaussi j'ai effectué qlq changements dans les functions d'appel, où j'ai gardé que les variables nécessaire, du fait que le taccesscontrol se charge des missions pénible à notre place

actuellement cette unité est celle du composant Taccesscontrol, j'ai testé et ça marche très bien, surtt la gestion hadles, dont je tien à te remercier pour cette notion.

merci de jeter un coup cette unité, et de me tenir compte de vos commentaire dont j'en suis certain que ça ne va pas manquer, surtt dans la déclaration
TAccessControl = class(TComponent)

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
unit AccessC3;
 
interface
 
uses Winapi.Windows,
     System.Classes,
     System.SysUtils,
     Dialogs;
 
Procedure LoadDll;
 
 Var
  NomDll:String;
  HandleDLL:THandle;
 
 
  Connect       : function  (Const Parameters: LPCSTR): THandle; StdCall;
  Disconnect    : Procedure (Handle:THandle);StdCall;
  PullLastError : function  ():Integer;StdCall;
 
  //// Section Set
 
  SetDeviceParam: function  (Handle : THandle; Const ItemValues:LPCSTR):Integer;StdCall;
 
  ControlDevice:  function   (Handle : THandle; operationid: LongInt; param1,
                              param2, param3, param4 : LongInt; Const options: LPCSTR): Integer; StdCall;
 
  SetDeviceData:  function   (Handle : THandle; Const tablename:LPCSTR; Const data:LPCSTR;
                              Const options:LPCSTR): Integer;StdCall;
 
  DeleteDeviceData:  function  (Handle : THandle; Const tablename:LPCSTR; Const data:LPCSTR; Const options:LPCSTR): Integer;StdCall;
 
  SearchDevice:      function  (commtype : LPCSTR; address : LPCSTR; buffer : PByte): Integer;StdCall;
 
  ModifyIPAddress:   function  (commtype : LPCSTR; address : LPCSTR; buffer : LPCSTR): Integer;StdCall;
 
  SetDeviceFileData: function  (Handle : THandle; Const filename : LPCSTR; buffer :LPCSTR;
                               buffersize:Integer; Const options:LPCSTR): Integer;StdCall;
 
  ProcessBackupData: function  (Const RevBef: PByte; fileLen: Integer; OutBuf:LPCSTR; Outsize:Integer):Integer;StdCall;
 
 
  ////////////// Section Get
 
  GetRTLog:       function  (Handle : THandle; buffer : PByte; buffersize:Integer): Integer;StdCall;
 
  GetDeviceParam: function  (Handle : THandle; Buffer:PByte; BufferSize: Integer;
                             Const Items:LPCSTR):Integer;StdCall;
 
  GetDeviceData:  function   (Handle : THandle; buffer:PByte; buffersize:Integer;
                             Const tablename:LPCSTR; Const filename:LPCSTR;
                             Const filter:LPCSTR; Const Option :LPCSTR):Integer;StdCall;
 
  GetDeviceDataCount:function  (Handle: THandle; Const tablename:LPCSTR; Const filter:LPCSTR; Const options: LPCSTR ): Integer;StdCall;
 
  GetDeviceFileData: function  (Handle : THandle; buffer:LPCSTR; buffersize:Integer;
                               Const filename: LPCSTR; Const options:LPCSTR):Integer;StdCall;
 
 
 
type
  TAccessControl = class(TComponent)
  private
     FProtocole,FIP     : String;
     FAlias,FPasswrd    : WideString;
     FMNumb,Fport,FTOut : Integer;
     FConnected         : Boolean;
     FHandle            : IntPtr;
 
     Function  GetConnected : Boolean;
     Procedure SetConnected (Value : Boolean);
 
     Function  GetProtocole : String;
     Procedure SetProtocole (Value : String);
 
     Function  GetIP : String;
     Procedure SetIP (Value : String);
 
     Function  GetPort : Integer;
     Procedure SetPort(Value : Integer);
 
     Function  GetTOut : Integer;
     Procedure SetTOut (Value : Integer);
 
     Function  GetPasswrd : WideString;
     Procedure SetPasswrd (Value :WideString);
 
     Function  GetAlias : WideString;
     Procedure SetAlias (Value :WideString);
 
     Function  GetMNumb : Integer;
     Procedure SetMNumb (Value : Integer);
 
 
 
  protected
    { Déclarations protégées }
  public
     Property protocole        : String     read Getprotocole  write Setprotocole;
     Property ipadresse        : String     read GetIP         write SetIP ;
     Property port             : Integer    read GetPort       write SetPort  ;
     Property timeout          : Integer    read GetTOut       write SetTOut ;
     Property Alias            : WideString read GetAlias      write SetAlias ;
     Property Passwrd          : WideString read GetPasswrd    write SetPasswrd;
     Property MachineNumber    : Integer    read GetMNumb      write SetMNumb ;
     Property Connected        : Boolean    read GetConnected  write SetConnected;
 
     constructor Create (AOwner:TComponent);override;
     Destructor Destroy; override;
 
     Function  PullLastErrorDev  ():Integer;
     Function  SetDeviceParamDev (Const ItemValues:String):Integer;
 
     Function  ControlDeviceDev  (operationid: LongInt; param1,
                                   param2, param3, param4 : LongInt; Const options: String): Integer;
     Function  SetDeviceDataDev  (Const tablename,data,options:String): Integer;
 
 
     Function  DeleteDeviceDataDev    (Const tablename, data, options:String): Integer;
 
     Function  ModifyIPAddressDev     (Const commtype, address: String;
                                       Var buffer: String): Integer;
 
     Function  SetDeviceFileDataDev   (Const filename : LPCSTR; Var buffer :LPCSTR;
                                        buffersize:Integer; Const options:LPCSTR): Integer;
 
 
 
    Function  GetDeviceParamDev (Var Buffer:String; Const Items:String):Integer;
    Function  GetDeviceDataDev  (Var buffer:String; Const tablename,filename,
                                 filter, Option :String):Integer;
 
    Function  GetDeviceDataCountDev  (Const tablename, filter,options: String): Integer;
    Function  GetRTLogDev            (Var buffer : String): Integer;
    Function  SearchDeviceDev        (Const commtype : String; Const address : String;
                                      Var buffer : String): Integer;
 
    Function  GetDeviceFileDataDev   (Var buffer:LPCSTR; buffersize:Integer;
                                      Const filename: LPCSTR; Const options:LPCSTR):Integer;
 
    Function  ProcessBackupDataDev   (Const RevBef: PByte; fileLen: Integer;
                                      OutBuf:LPCSTR; Outsize:Integer):Integer;
 
  published
    { Déclarations publiées }
 
  end;
 
 
procedure Register;
 
implementation
{$POINTERMATH ON}
 
 
procedure Register;
begin
  RegisterComponents('ActiveX', [TAccessControl]);
end;
 
 
constructor TAccessControl.Create(AOwner: TComponent);
begin
 inherited;
 LoadDll;
 protocole     := 'TCP';
 ipadresse     := '192.168.1.201';
 port          := 4370;
 timeout       := 4000;
 MachineNumber := 1;
 Alias         := 'Machine';
 FHandle       := 0;
end;
 
destructor TAccessControl.Destroy;
begin
 FreeLibrary(HandleDLL) ;
inherited Destroy;
end;
 
function TAccessControl.GetProtocole: String;
begin
  Result := FProtocole;
end;
 
procedure TAccessControl.SetProtocole(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FProtocole := Value;
    end
  else FProtocole :=FProtocole;
end;
 
function TAccessControl.GetIP: String;
begin
  Result := FIP;
end;
 
procedure TAccessControl.SetIP(Value: String);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FIP := Value;
    end
  else FIP := FIP;
end;
 
function TAccessControl.GetAlias: WideString;
begin
  Result := FAlias;
end;
 
procedure TAccessControl.SetAlias(Value: WideString);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FAlias := Value;
    end
  else FAlias := FAlias;
end;
 
function TAccessControl.GetPasswrd: WideString;
begin
  Result := FPasswrd;
end;
 
procedure TAccessControl.SetPasswrd(Value: WideString);
begin
  if Trim(Value) <> EMptyStr then
    begin
      FPasswrd := Value;
    end
  else FPasswrd := FPasswrd;
end;
 
function TAccessControl.GetPort: Integer;
begin
  Result := FPort;
end;
 
procedure TAccessControl.SetPort(Value: Integer);
begin
  if Value > 0 then
    begin
      FPort := Value;
    end
  else FPort := FPort;
end;
 
function TAccessControl.GetTOut: Integer;
begin
  Result := FTOut;
end;
 
procedure TAccessControl.SetTout(Value: Integer);
begin
  if Value > 0 then
    begin
      FTOut := Value;
    end
  else FTOut := FTOut;
end;
 
function TAccessControl.GetMNumb: Integer;
begin
  Result := FMNumb;
end;
 
procedure TAccessControl.SetMNumb(Value: Integer);
begin
  if Value > 0 then
    begin
      FMNumb := Value;
    end
  else FMNumb := FMNumb;
end;
 
function TAccessControl.GetConnected: Boolean;
begin
  Result := FConnected;
end;
 
procedure TAccessControl.SetConnected(Value: Boolean);
Var Adr : String;
begin
  Adr := 'protocol='+protocole+',ipaddress='+ipadresse+',port='+Port.ToString+
         ',timeout='+Timeout.ToString+',passwd='+Passwrd;
  if Value then
  begin
    FHandle := Connect(LPCSTR(UTF8Encode(Adr)));
    FConnected := FHandle  > 0;
  end
  else
  begin
     FConnected := False;
     Disconnect (FHandle);
     FHandle  := 0;
  end;
end;
 
Function TAccessControl.PullLastErrordev():Integer;
Begin
 Result := PullLastError ;
End;
 
Function TAccessControl.SetDeviceParamdev (Const ItemValues:String):Integer;
Begin
 Result := SetDeviceParam(FHandle, LPCSTR(UTF8Encode(ItemValues)));
End;
 
Function TAccessControl.GetRTLogdev  (Var buffer : String): Integer;
Var Buf : Array of Byte;
    Chaine : String;
    buffersize : Integer;
Begin
  buffersize := 256;
  SetLength(Buf,buffersize);
  Result := GetRTLog  (FHandle, @Buf [0], buffersize);
  Chaine := TEncoding.Default.GetString(@Buf[0]);
  Buffer := Chaine;
End;
 
Function TAccessControl.GetDeviceParamdev (Var Buffer:String;
                             Const Items:String):Integer;
Var Buf : Array of Byte;
    Chaine : String;
    buffersize : Integer;
Begin
 BufferSize := 10 * 1024 * 1024;
 SetLength(Buf,buffersize);
 Result := GetDeviceParam (FHandle,  @Buf [0], BufferSize, LPCSTR(UTF8Encode(Items)));
 Chaine := TEncoding.Default.GetString(@Buf[0]);
 Buffer := Chaine;
End;
 
Function TAccessControl.ControlDevicedev  (operationid: LongInt; param1,
                                           param2, param3, param4 : LongInt;
                                           Const options: String): Integer;
Begin
  Result := ControlDevice  (FHandle,  operationid, param1,param2, param3, param4,
                            LPCSTR(UTF8Encode(options)));
End;
 
Function TAccessControl.SetDeviceDatadev  (Const tablename,data,options: String): Integer;
Begin
  Result := SetDeviceData  (FHandle,  LPCSTR(UTF8Encode(tablename)), LPCSTR(UTF8Encode(data)),
                            LPCSTR(UTF8Encode(options)));
End;
 
Function TAccessControl.GetDeviceDatadev  (Var buffer:String; Const tablename,
                                           filename, filter, Option :String):Integer;
Var Buf : Array of Byte;
    Chaine : String;
    buffersize : Integer;
Begin
  buffersize := 10 * 1024 * 1024;
  SetLength (Buf,buffersize);
  Result := GetDeviceData  (FHandle,  @Buf [0], buffersize,
                            LPCSTR(UTF8Encode(tablename)),
                            LPCSTR(UTF8Encode(filename)),
                            LPCSTR(UTF8Encode(filter)),
                            LPCSTR(UTF8Encode(Option)));
 Chaine := TEncoding.Default.GetString(@Buf[0]);
 Buffer := Chaine;
End;
 
Function TAccessControl.GetDeviceDataCountdev  (Const tablename,filter ,options :String): Integer;
Begin
  Result := GetDeviceDataCount (FHandle,  LPCSTR(UTF8Encode(tablename)),
                                LPCSTR(UTF8Encode(filter)),
                                LPCSTR(UTF8Encode(options)));
End;
 
Function TAccessControl.DeleteDeviceDatadev    (Const tablename, data, options:String): Integer;
Begin
  Result := DeleteDeviceData (FHandle,LPCSTR(UTF8Encode(tablename)),
                              LPCSTR(UTF8Encode(data)),
                              LPCSTR(UTF8Encode(options)));
End;
 
Function TAccessControl.SearchDevicedev   (Const commtype,address : String;
                                           Var buffer : String): Integer;
Var Buf : Array of Byte;
    Chaine : String;
Begin
  SetLength (Buf,64*1024);
  Result := SearchDevice   (LPCSTR(UTF8Encode(commtype)),
                            LPCSTR(UTF8Encode(address)),@Buf [0]);
  Chaine := TEncoding.Default.GetString(@Buf[0]);
  Buffer := Chaine;
End;
 
Function TAccessControl.ModifyIPAddressdev(Const commtype, address: String;
                                           Var buffer: String): Integer;
Begin
  Result := ModifyIPAddress(LPCSTR(UTF8Encode(commtype)),
                            LPCSTR(UTF8Encode(address)),
                            LPCSTR(UTF8Encode(buffer)));
End;
 
Function TAccessControl.SetDeviceFileDatadev (Const filename : LPCSTR; Var buffer :LPCSTR;
                               buffersize:Integer; Const options:LPCSTR): Integer;
Begin
  Result := SetDeviceFileData (FHandle, filename,buffer,buffersize,options);
End;
 
Function TAccessControl.GetDeviceFileDatadev (Var buffer:LPCSTR; buffersize:Integer;
                                              Const filename: LPCSTR;
                                              Const options:LPCSTR):Integer;
Begin
  Result := GetDeviceFileData   (FHandle,  buffer, buffersize,filename, options);
End;
 
Function TAccessControl.ProcessBackupDatadev (Const RevBef: PByte; fileLen:
                                              Integer; OutBuf:LPCSTR; Outsize:
                                              Integer):Integer;
Begin
  Result := ProcessBackupData   (RevBef,fileLen,OutBuf,Outsize);
End;
procedure LoadDll ;
begin
  NomDll:='plcommpro.dll';
  HandleDLL:=LoadLibrary(PChar(NomDll));
  if HandleDLL = 0 then
   Begin
    ShowMessage('Erreur chargement de la DLL');
    Exit;
   End;
 
 Connect            := GetProcAddress(HandleDLL, pWideChar('Connect'));
 Disconnect         := GetProcAddress(HandleDLL, pWideChar('Disconnect'));
 PullLastError      := GetProcAddress(HandleDLL, pWideChar('PullLastError'));
 SetDeviceParam     := GetProcAddress(HandleDLL, pWideChar('SetDeviceParam'));
 GetDeviceParam     := GetProcAddress(HandleDLL, pWideChar('GetDeviceParam'));
 ControlDevice      := GetProcAddress(HandleDLL, pWideChar('ControlDevice'));
 SetDeviceData      := GetProcAddress(HandleDLL, pWideChar('SetDeviceData'));
 GetDeviceData      := GetProcAddress(HandleDLL, pWideChar('GetDeviceData'));
 GetDeviceDataCount := GetProcAddress(HandleDLL, pWideChar('GetDeviceDataCount'));
 DeleteDeviceData   := GetProcAddress(HandleDLL, pWideChar('DeleteDeviceData'));
 GetRTLog           := GetProcAddress(HandleDLL, pWideChar('GetRTLog'));
 SearchDevice       := GetProcAddress(HandleDLL, pWideChar('SearchDevice'));
 ModifyIPAddress    := GetProcAddress(HandleDLL, pWideChar('ModifyIPAddress'));
 SetDeviceFileData  := GetProcAddress(HandleDLL, pWideChar('SetDeviceFileData'));
 GetDeviceFileData  := GetProcAddress(HandleDLL, pWideChar('GetDeviceFileData'));
 ProcessBackupData  := GetProcAddress(HandleDLL, pWideChar('ProcessBackupData'));
end;
 
end.

**ShaiLeTroll** · 06/07/2016, 08h46

J'aurais tout simplement choisi TAccessControl = class(TObject).
Si tu n'utilise ni la propriété Name ni FindComponent, le TComponent ne t'apportera rien hormis une libération implicite par le Owner mais pour ce genre d'objet,
je pense que maitriser le cycle de vie de l'objet est préférable !

Donc si ça fonctionne, c'est donc

!

**Ouail1825** · 06/07/2016, 11h48

oui ça fonctionne bien, et un chapeau à toi grand

c'est résolu ...
pour ceux qui trouvent des difficultés pour gérer ce genre d'appareils de zkteco, cette unité avec les dll fournies ça marche parfaitement

**the_starter** · 12/07/2016, 19h34

bonjour à vous je suis débutant en programmation (juste les bases) et j'aimerais réussir à me connecter a mon équipement ZKTeco en c# je compte énormément sur vous pour pouvoir avancé dans mon projet . Merci bien

**Andnotor** · 13/07/2016, 09h21

Merci de poster les questions C# sur le forum adéquate.

**Ouail1825** · 14/07/2016, 15h47

les SDK de Zkteco, sont fournis avec des demos en c#, télécharge les depuis le site constructeurs.
Merci

**SheikhAmmar** · 05/02/2022, 08h47

Envoyé par Ouail1825

le lien pour les SDK et la documentation de la DLL est: https://drive.google.com/open?id=0Bz...UNDRGtmYWpKNUU

**SergioMaster** · 05/02/2022, 10h13

Bonjour,

Plutôt que de tirer sur le pianiste, qui est absent depuis des années de ce forum (dernière activité : 02/07/2018 13h47)
un peu de recherche simple avec les mots clés "sdk" et "zkteco" vous donneront un lien de téléchargement du dit SDK.

S'il s'agit du lien de téléchargement proposé par Ouail1825 sur un drive google contenant le SQK de l'époque
1- je doute de la validité des licences
2- tentez de contacter directement l'auteur par mail privé (clic sur le pseudo et mail privé)

Composant non visuel (PullSDK-ZkTeko)

Composants VCL Delphi

Discussions similaires

Partager

Partager