Funcionamento do Input
Input
O módulo Input é responsável por controlar os dispositivos ópticos e inerciais, iniciar os dispositivos, parar e ter um retorno se o mesmo está disponível.
O padrão de projetos utilizado no módulo Input foi o Abstract Factory. O Abstract Factory é um padrão de projeto do tipo criacional que permite criar famílias de objetos relacionados sem ter que especificar suas classes concretas. Proporciona algumas vantagens como saber que os produtos que você obtém de uma fábrica são compatíveis entre eles, fácil manutenção e evita acoplamento entre produto concreto e código cliente. Como desvantagem pode tornar o código mais complexo num primeiro momento devido a maior quantidade de classes e interfaces.
No framework o AbstractFactory declara uma interface para operações que irão criar objetos AbstractProduct. Nesse caso, são dispositivos de entrada. Essa classe contém dois métodos, o método GetInput que é um método abstrato que será implementado pelas classes de fábrica filhas. O outro método, CreateInputFactory recebe um parâmetro de entrada, ou seja, tipo de fábrica e, em seguida, cria e retorna o objeto de fábrica apropriado para o chamador.
//AbstractFactory
namespace AbstractFactoryDesignPattern
{
public abstract class InputFactory
{
public abstract Input GetInput(string inputType);
public static InputFactory CreateInputFactory(string factoryType)
{
if (factoryType.Equals("Optical"))
return new OpticalInputFactory();
else
return new InertialInputFactory();
}
}
}
A classe concreta implementa a classe AbstractFactory (InputFactory). Em nosso trabalho, essa classe vai implementar o método GetInput da classe InputFactory. Existem dois tipos concretos de fábricas em nosso exemplo, ou seja, InertialInputFactory para dispositivos inerciais e OpticalInputFactory para dispositivos ópticos.
//ConcreteFactory1
namespace AbstractFactoryDesignPattern
{
public sealed class InertialInputFactory : InputFactory
{
public override Input GetInput(string inputType)
{
if (inputType.Equals("Bsn"))
{
return new Bsn();
}
else
return null;
}
}
}
Podemos observar no código supracitado, que o método GetInput cria e retorna o objeto inercial apropriado, ou seja, BSN, entre outros, com base no parâmetro de entrada, isto significa, o InputType recebido. Analogamente, o mesmo vale para os dispositivos ópticos da classe concreta OpticalInputFactory.
//ConcreteFactory2
namespace AbstractFactoryDesignPattern
{
public sealed class OpticalInputFactory : InputFactory
{
public override Input GetInput(string inputType)
{
if (inputType.Equals("Mediapipe"))
{
return new Mediapipe();
}
else if (inputType.Equals("Kinect"))
{
return new Kinect();
}
else
return null;
}
}
}
Conforme apresentado no código a interface declara os métodos do Produto. Em nosso framework, são os métodos Start, Stop e IsReady do objeto Input. O método Start fica responsável por iniciar o dispositivo, o Stop por parar o dispositivo iniciado e o IsReady verifica se está pronto ou não.
//Abstract Product
namespace AbstractFactoryDesignPattern
{
public interface Input
{
public bool Start();
public bool Stop();
public bool IsReady();
}
}
A classe concreta do produto implementa a interface AbstractFactory (InputFactory) para criar produtos concretos. Em nosso exemplo, as classes dos produtos são Mediapipe, BSN e Kinect.
Podemos ver um exemplo da classe Mediapipe, Kinect e BSN que implementam os métodos Start, Stop e IsReady da interface Input.
//Concrete Product
namespace AbstractFactoryDesignPattern
{
public class Mediapipe : Input
{
private static bool _isMediaPipeReady;
public bool Start()
{
return _isMediaPipeReady = true;
}
public bool Stop()
{
return _isMediaPipeReady = false;
}
public bool IsReady()
{
return _isMediaPipeReady;
}
}
}
//Concrete Product
namespace AbstractFactoryDesignPattern
{
public class Kinect : Input
{
private static bool _isKinectReady;
public bool Start()
{
return _isKinectReady = true;
}
public bool Stop()
{
return _isKinectReady = false;
}
public bool IsReady()
{
return _isKinectReady;
}
}
}
//Concrete Product
namespace AbstractFactoryDesignPattern
{
public class Bsn : Input
{
private static bool _isBsnReady;
public bool Start()
{
return _isBsnReady = true;
}
public bool Stop()
{
return _isBsnReady = false;
}
public bool IsReady()
{
return _isBsnReady;
}
}
}
O Cliente usa as interfaces AbstractFactory e AbstractProduct para criar uma família de objetos relacionados.
using UnityEngine;
namespace AbstractFactoryDesignPattern
{
class ClientInput : MonoBehaviour
{
private Input input;
private InputFactory inputFactory;
// Start is called before the first frame update
void Start()
{
// Create the OpticalInput factory object by passing the factory type as Optical
inputFactory = InputFactory.CreateInputFactory("Optical");
// Get Mediapipe Input object by passing the input type as Mediapipe
input = inputFactory.GetInput("Mediapipe");
input.Start();
// Get Kinect Input object by passing the input type as Kinect
input = inputFactory.GetInput("Kinect");
input.Start();
}
// Update is called once per frame
void Update()
{
}
}
}