Caro desenvolvedor, aqui serão relatados os passos para que você possa realizar a integração com seu software.
Vale lembrar que fizemos DLLs, logo você conseguirá integrar em linguagens que suportam tal tecnologia, como exemplo
C#, .Net, Delphi e Java (não homologados).
Abaixo você pode realizar o download do nosso SDK
Como utilizamos C# para produzir as DLLs, iremos exemplificar nossas funções nessa linguagem, mas estamos à disposição para esclarecer suas dúvidas, ok?
Antes de tudo, deve-se realizar a importação da dll Athena.Interface em seu projeto.
Coloque TODAS as dlls enviadas na pasta do seu projeto executável. Ex.: /bin/debug ou /bin/release
Para definir as configurações padrões, utilize a seguinte função:
AppSettings.Instance = new AppSettings()
{
DeviceConnectionTimeout = 0,
M33ConnectionPort = _PORT_DEVICE, //(ex: 5005)
RequireSerialNumber = false
};
Para realizar a comunicação com um dispositivo, necessitamos informar o modelo. Sendo assim, temos abaixo:
Para realizar a comunicação com um dispositivo, utilize as seguintes propriedades do objeto Device
Device dispositivo = new Device()
{
IpAddress = _IP_DEVICE,
Password = _PASSWORD_DEVICE,
Id = _ID_COMMUNICATION_DEVICE,
Port = _PORT_DEVICE, //(ex: 5005)
Model = DeviceModel.A030
};
Para criar um usuário para cadastramento no dispositivo, deve-se utilizar o objeto UserData.
Este contém as seguintes propriedades:
//Identificador do usuário a ser enviado para o dispositivo
public long Id;
// Nome do usuário a ser enviado para o dispositivo
public string Name;
//Template biométrico facial extraído do dispositivo
//Válido somente para os dispositivos A020, A030 e L030
public byte[] FaceData;
//Foto extraída do dispositivo (base64, UNDER DE 8kb, 120x160)
//Obs.: Caso esteja utilizando o dispositivo da família A040, A0405 e A060, o tamanho da foto é permitido ser maior
//uma vez que este parâmetro é utilizado para cadastramento da FACE do usuário
public string PhotoData;
//Senha do usuário
//Válido somente para os dispositivos A020, A030 e L030
public string Password;
//Cartão RFID
public long CardData;
//Data de início da permissão de acesso do usuário
public DateTime? StartExpirationDate;
//Data final da permissão de acesso do usuário
public DateTime? EndExpirationDate;
//ZONA DE TEMPO
//Válido somente para os dispositivos A020, A030 e L030
// Zona de Tempo 1 do usuário
public int TimeZone1;
// Zona de Tempo 1 do usuário
public int TimeZone2;
// Zona de Tempo 1 do usuário
public int TimeZone3;
// Zona de Tempo 1 do usuário
public int TimeZone4;
// Zona de Tempo 1 do usuário
public int TimeZone5;
// Privilégios do usuário. Obs: Somente dispositivos A020, A030 e L030
public UserPrivilege Privilege;
Crie a instância do objeto UserData:
UserData user = new UserData();
A partir da versão 1.5.0 recomendamos a utilização da interface DeviceInterface para realizar a chamada dos métodos:
Exemplo:
DeviceInterface.DeleteAllUsers(dispositivo);
DeviceInterface.RegisterUser(dispositivo, user);
Para os dispositivos A040, A0405, A050, A060 e A060T é necessário utilizar os comandos em um tipo de Task. Abaixo, é mostrado um exemplo de utilização com retorno de um dado:
No caso da nossa implementação em C#, utilizamos o método Task de System.Threading.Tasks.
Task task = Task.Run(() =>
{
//Method to visualize specific user on device
return DeviceInterface.VisualizeUser(dev, userNumber);
});
task.Wait();
UserData user = task.Result;
Para realizar um cadastramento remoto (dispositivos A030), envie somente os atributos ID e NOME, assim dispositivo irá iniciar o cadastramento automaticamente.
Caso queira realizar um cadastramento manualmente, há duas opções:
DeviceInterface.RegisterUser(dispositivo, user);
DeviceInterface.RegisterManyUsers(dispositivo, UserData[] users);
int count = DeviceInterface.CountUsers(dispositivo);
UserData person = DeviceInterface.VisualizeUser(dispositivo, (int)ID_USER);
UserData[] people = DeviceInterface.VisualizeAllUsers(dispositivo);
DeviceInterface.DeleteUser(dispositivo, ID_USER);
DeviceInterface.RegisterManyUsers(dispositivo, long[] users);
DeviceInterface.DeleteAllUsers(dispositivo);
DeviceInterface.UnlockDoor(dispositivo);
List logs = DeviceInterface.FetchLogs(dispositivo);
DeviceInterface.DeleteAccessLogs(dispositivo);
DeviceInterface.SetFixedIP(dispositivo, ip, gateway, mask, dns, dhcp);
DeviceInterface.SetWiFiConfiguration(dispositivo, ssid, password);
DeviceInterface.SetLogo(dispositivo, imageBase64);
DeviceInterface.SetDateTime(dateTime, dispositivo);
DeviceInterface.SetDateTime(dateTime, dispositivo, DeviceTimeZone.Brasilia);
DeviceInterface.ResetDevice(dispositivo, DeletionTypeEnum.OnlyData);
DeviceInterface.RestartDevice(dispositivo);
string url = "http://www.google.com.br"
DeviceInterface.SetCallBackOnRecognize(dispositivo, url);
bool utilizatemperatura = true;
double valortemperatura = 37.3;
DeviceInterface.SetTemperature(dispositivo, utilizatemperatura, valortemperatura);
bool usamascara = true;
bool utilizaalertavoz = true;
string textalerta = "Please, wear a mask!";
DeviceInterface.SetMaskUsage(dispositivo, usamascara, utilizaalertavoz, textalerta);
bool utilizaalertavoz = true;
string mensagem = "Hello!";
DeviceInterface.ShowMessage(dispositivo, utilizaalertavoz, mensagem);
Para realizar a comunicação ao dispositivo através de um web service, por exemplo, deve-se colocar as funções de comunicação em uma Thread separada de comunicação:
Thread thread = new Thread(delegate () { função });
thread.Start();
Os dispositivos A040 esperam uma rota HTTP para enviarem o callback de acesso. Sendo assim, utilize a função abaixo para realizar a configuração da rota:
string url = "http://localhost:2060/device/callback";
DeviceInterface.SetCallBackOnRecognize(dispositivo, url);
Vale ressaltar que a rota deve ser do tipo POST e esperar como parâmetro um objeto do tipo CallbackModel contido em nosso SDK.
Essa classe possui os seguintes atributos:
//Image Path of user recognized
public string Path { get; set; }
//Device IP
public string Ip { get; set; }
//Serial of device
public string DeviceKey { get; set; }
//Id of user recognized
public string PersonId { get; set; }
//Time of recognition (unix timespan format)
public long Time { get; set; }
//Type of recognition: FACE / CARD
public string Type { get; set; }
/// Para dispositivos A0405 e A060T
//Score of recognition
public string SearchScore { get; set; }
//Score of liveness
public string LivenessScore { get; set; }
//Temperature Value of recognition
public string Temperature { get; set; }
//Temperature Default
public string Standard { get; set; }
//State of Temperatura: 1 NORMAL - 2 ABNORMAL
public string TemperatureState { get; set; }
Após o recebimento do comando, deve-se retornar para o dispositivo uma confirmação do recebimento da mensagem.
A confirmação deve-se se dar na resposta a requisição através das funções:
//Função disponibilizada no SDK
CallbackModel.CallbackFailed();
//Caso queira desenvolver por você mesmo, utilize o retorno abaixo para a requisição HTTP 200:
var callback_failed = {
result = 1,
success = false
};
//Função disponibilizada no SDK
CallbackModel.CallbackSuccess();
//Caso queira desenvolver por você mesmo, utilize o retorno abaixo para a requisição HTTP 200:
var callback_success = {
result = 1,
success = true
};
Caso o retorno não seja realizado, o dispositivo continuará realizando a mesma requisição para o usuário reconhecido.
Os dispositivos A030, se habilitados através da opção Modo de Transferência de Evento, ou Event Transfer Mode, podem enviar callbacks diretamente ao servidor via protocolo UDP:
A porta que o SDK escutará os callbacks é definida pela propriedade M33UDPListeningPort
da classe AppSettings
Estes callbacks podem ser configurados através de eventos na classe Biomtech.Athena.Interface.Devices.M33.M33Connection.
Os eventos são chamados:
OnReceivedManagementCallback, OnReceivedSuccessRecognitionCallback e OnReceivedFailedRecognitionCallback
e passam respectivamente como parâmetro objetos do tipo
CallbackObject, RecognitionSuccessCallback e RecognitionFailureCallback
os quais são definidos como:
public class CallbackObject {
public string IpAddress { get; set; } //Endereço de IP do dispositivo
public int MachineID { get; set; } //Número identificador do dispositivo
public DateTime Date {get; } //Data da ocorrência do callback
public int Weekday { get; set; } //Dia da semana da data
public EventType EventType { get; set; } //Tipo de evento
public int UserID { get; set; } //Identificador do usuário relacionado
}
public class RecognitionSuccessCallback : CallbackObject {
}
public class RecognitionSuccessCallback : CallbackObject {
public ReasonOfFailureType ReasonOfFailure { get; set; } //Razão do não reconhecimento
}
Caso voce queira redirecionar os callbacks para alguma(s) máquina(s) da rede, a classe Biomtech.Athena.Interface.Devices.M33.M33Connection possui a propriedade
IsCallbackReroutingEnabled
desabilitada por padrão, mas que se habilitada, redirecionará os pacotes para o IP ou máscara desejados.
O IP ou máscara podem ser escolhidos através do método estático SetCallbackBroadcastRange
, passando um endereço de IP direto ou com máscara para broadcasting.
A porta que será efetuado o broadcasting é definida pela propriedade M33UDPBroadcastingPort
da classe AppSettings