iOS MFI controller connection issue - ios

Question

i have this code that is a Plugin for Unreal Engine 4 is to allow MFI game controllers (Physical Bluetooth Gamepad, Joystick) to be used in my game on iOS devices
the plugin works fine if the game (App) is launched before connecting the controller
the problem is if the game controller is connected before launching the game the game crashes after the splash screen
also disconnecting the controller whilst the game is running closes/crashes the game
any advice is much appreciated
#include "IOSInputInterfacePrivatePCH.h"
#include "IInputInterface.h"
#include "IOSGamepad.h"
/** Beginning of FGCControllerNotificationHandler class */
#if PLATFORM_IOS
#interface FGCControllerNotificationHandler : NSObject
#property FIOSGamepad* device;
+ (id)sharedInstance;
#end
#implementation FGCControllerNotificationHandler
#synthesize device;
- (id)init
{
self = [super init];
return self;
}
+ (id)alloc
{
return [super allocWithZone:NULL];
}
+ (id)allocWithZone:(NSZone *)zone {
return [[self sharedInstance] retain];
}
- (id)copyWithZone:(NSZone *)zone {
return self;
}
- (id)retain {
return self;
}
- (NSUInteger)retainCount {
return NSUIntegerMax; /** denotes an object that cannot be released */
}
- (oneway void)release {
/** never release */
}
- (id)autorelease {
return self;
}
- (void)dealloc {
[super dealloc];
}
+ (FGCControllerNotificationHandler *)sharedInstance
{
static FGCControllerNotificationHandler* instance;
#synchronized(self)
{
if (instance == nil)
{
instance = [[self alloc] init];
}
}
return instance;
}
- (void)registerObservers:(FIOSGamepad *)inDevice
{
self.device = inDevice;
NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
/** Assign controller when connected */
[center addObserver:self
selector:#selector(setupControllers)
name:GCControllerDidConnectNotification
object:nil];
/** Do something after controller disconnection */
[center addObserver:self
selector:#selector(cleanControllers)
name:GCControllerDidDisconnectNotification
object:nil];
/** Search for another controller */
[GCController startWirelessControllerDiscoveryWithCompletionHandler:nil];
/** Assign controller id for known controllers */
if ([[GCController controllers] count] > 0)
{
[self setupControllers];
}
}
- (void)setupControllers
{
if(device != nil)
{
self.device->OnControllerConnected();
}
}
- (void)cleanControllers
{
if(device != nil)
{
self.device->OnControllerDisconnected();
}
}
- (int32)getControllerCount
{
return (int32)[[GCController controllers] count];
}
- (TArray<GCController *>)getConnectedControllers
{
TArray<GCController *> availableControllers;
for (GCController* c in [GCController controllers])
{
availableControllers.Add(c);
}
return availableControllers;
}
#end
#endif
/** End of FGCControllerNotificationHandler class */
/** Beginning of FIOSGamepad class */
FIOSGamepad::FIOSGamepad(const TSharedRef<FGenericApplicationMessageHandler>& InMessageHandler) :
MessageHandler(InMessageHandler)
{
#if PLATFORM_IOS
/** In the engine, all controllers map to xbox controllers for consistency */
IOSToXboxControllerMapping[0] = 0; // FaceButtonBottom
IOSToXboxControllerMapping[1] = 1; // FaceButtonRight
IOSToXboxControllerMapping[2] = 2; // FaceButtonLeft
IOSToXboxControllerMapping[3] = 3; // FaceButtonTop
IOSToXboxControllerMapping[4] = 4; // L1
IOSToXboxControllerMapping[5] = 5; // R1
IOSToXboxControllerMapping[6] = 6; // None
IOSToXboxControllerMapping[7] = 7; // None
IOSToXboxControllerMapping[8] = 8; // None
IOSToXboxControllerMapping[9] = 9; // None
IOSToXboxControllerMapping[10] = 10; // L2
IOSToXboxControllerMapping[11] = 11; // R2
IOSToXboxControllerMapping[12] = 12; // Dpad up
IOSToXboxControllerMapping[13] = 13; // Dpad down
IOSToXboxControllerMapping[14] = 14; // Dpad left
IOSToXboxControllerMapping[15] = 15; // Dpad right
IOSToXboxControllerMapping[16] = 16; // Left stick up
IOSToXboxControllerMapping[17] = 17; // Left stick down
IOSToXboxControllerMapping[18] = 18; // Left stick left
IOSToXboxControllerMapping[19] = 19; // Left stick right
IOSToXboxControllerMapping[20] = 20; // Right stick up
IOSToXboxControllerMapping[21] = 21; // Right stick down
IOSToXboxControllerMapping[22] = 22; // Right stick left
IOSToXboxControllerMapping[23] = 23; // Right stick right
Buttons[0] = FGamepadKeyNames::FaceButtonBottom;
Buttons[1] = FGamepadKeyNames::FaceButtonRight;
Buttons[2] = FGamepadKeyNames::FaceButtonLeft;
Buttons[3] = FGamepadKeyNames::FaceButtonTop;
Buttons[4] = FGamepadKeyNames::LeftShoulder;
Buttons[5] = FGamepadKeyNames::RightShoulder;
Buttons[6] = FGamepadKeyNames::SpecialRight;
Buttons[7] = FGamepadKeyNames::SpecialLeft;
Buttons[8] = FGamepadKeyNames::LeftThumb;
Buttons[9] = FGamepadKeyNames::RightThumb;
Buttons[10] = FGamepadKeyNames::LeftTriggerThreshold;
Buttons[11] = FGamepadKeyNames::RightTriggerThreshold;
Buttons[12] = FGamepadKeyNames::DPadUp;
Buttons[13] = FGamepadKeyNames::DPadDown;
Buttons[14] = FGamepadKeyNames::DPadLeft;
Buttons[15] = FGamepadKeyNames::DPadRight;
Buttons[16] = FGamepadKeyNames::LeftStickUp;
Buttons[17] = FGamepadKeyNames::LeftStickDown;
Buttons[18] = FGamepadKeyNames::LeftStickLeft;
Buttons[19] = FGamepadKeyNames::LeftStickRight;
Buttons[20] = FGamepadKeyNames::RightStickUp;
Buttons[21] = FGamepadKeyNames::RightStickDown;
Buttons[22] = FGamepadKeyNames::RightStickLeft;
Buttons[23] = FGamepadKeyNames::RightStickRight;
bNeedsControllerStateUpdate = true;
InitialButtonRepeatDelay = 0.2f;
ButtonRepeatDelay = 0.1f;
/** Initialize ControllerStates */
for (int32 ControllerIndex=0; ControllerIndex < MAX_NUM_IOS_CONTROLLERS; ++ControllerIndex)
{
FControllerState& ControllerState = ControllerStates[ControllerIndex];
FMemory::Memzero(&ControllerState, sizeof(FControllerState));
ControllerState.ControllerId = ControllerIndex;
}
[[FGCControllerNotificationHandler sharedInstance] registerObservers:this];
#endif
}
FIOSGamepad::~FIOSGamepad()
{
}
void FIOSGamepad::Tick(float DeltaTime)
{
}
void FIOSGamepad::SendControllerEvents()
{
#if PLATFORM_IOS
for (int32 ControllerIndex=0; ControllerIndex < MAX_NUM_IOS_CONTROLLERS; ++ControllerIndex)
{
FControllerState& ControllerState = ControllerStates[ControllerIndex];
if (!ControllerState.bIsConnected && bNeedsControllerStateUpdate)
{
ControllerState.bIsConnected = (ControllerIndex < ((int32) [[GCController controllers] count]));
}
if (ControllerState.bIsConnected)
{
bool CurrentStates[MAX_NUM_IOS_CONTROLLER_BUTTONS] = {0};
GCController* Controller = [GCController controllers][ControllerIndex];
if (Controller.extendedGamepad != nil)
{
GCExtendedGamepad* ExGamepad = Controller.extendedGamepad;
/** Check Analog state */
if(ControllerState.LeftXAnalog != ExGamepad.leftThumbstick.xAxis.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::LeftAnalogX, ControllerState.ControllerId, ExGamepad.leftThumbstick.xAxis.value);
ControllerState.LeftXAnalog = ExGamepad.leftThumbstick.xAxis.value;
}
if(ControllerState.LeftYAnalog != ExGamepad.leftThumbstick.yAxis.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::LeftAnalogY, ControllerState.ControllerId, ExGamepad.leftThumbstick.yAxis.value);
ControllerState.LeftYAnalog = ExGamepad.leftThumbstick.yAxis.value;
}
if(ControllerState.RightXAnalog != ExGamepad.rightThumbstick.xAxis.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::RightAnalogX, ControllerState.ControllerId, ExGamepad.rightThumbstick.xAxis.value);
ControllerState.RightXAnalog = ExGamepad.rightThumbstick.xAxis.value;
}
if(ControllerState.RightYAnalog != ExGamepad.rightThumbstick.yAxis.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::RightAnalogY, ControllerState.ControllerId, ExGamepad.rightThumbstick.yAxis.value);
ControllerState.RightYAnalog = ExGamepad.rightThumbstick.yAxis.value;
}
if(ControllerState.LeftTriggerAnalog != ExGamepad.leftTrigger.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::LeftTriggerAnalog, ControllerState.ControllerId, ExGamepad.leftTrigger.value);
ControllerState.LeftTriggerAnalog = ExGamepad.leftTrigger.value;
}
if(ControllerState.RightTriggerAnalog != ExGamepad.rightTrigger.value)
{
MessageHandler->OnControllerAnalog(FGamepadKeyNames::RightTriggerAnalog, ControllerState.ControllerId, ExGamepad.rightTrigger.value);
ControllerState.RightTriggerAnalog = ExGamepad.rightTrigger.value;
}
/** Get the current state of all buttons */
CurrentStates[IOSToXboxControllerMapping[0]] = ExGamepad.buttonA.pressed;
CurrentStates[IOSToXboxControllerMapping[1]] = ExGamepad.buttonB.pressed;
CurrentStates[IOSToXboxControllerMapping[2]] = ExGamepad.buttonX.pressed;
CurrentStates[IOSToXboxControllerMapping[3]] = ExGamepad.buttonY.pressed;
CurrentStates[IOSToXboxControllerMapping[4]] = ExGamepad.leftShoulder.pressed;
CurrentStates[IOSToXboxControllerMapping[5]] = ExGamepad.rightShoulder.pressed;
CurrentStates[IOSToXboxControllerMapping[6]] = false;
CurrentStates[IOSToXboxControllerMapping[7]] = false;
CurrentStates[IOSToXboxControllerMapping[8]] = false;
CurrentStates[IOSToXboxControllerMapping[9]] = false;
CurrentStates[IOSToXboxControllerMapping[10]] = ExGamepad.leftTrigger.value > IOS_TRIGGER_THRESHOLD;
CurrentStates[IOSToXboxControllerMapping[11]] = ExGamepad.rightTrigger.value > IOS_TRIGGER_THRESHOLD;
CurrentStates[IOSToXboxControllerMapping[12]] = ExGamepad.dpad.up.pressed;
CurrentStates[IOSToXboxControllerMapping[13]] = ExGamepad.dpad.down.pressed;
CurrentStates[IOSToXboxControllerMapping[14]] = ExGamepad.dpad.left.pressed;
CurrentStates[IOSToXboxControllerMapping[15]] = ExGamepad.dpad.right.pressed;
CurrentStates[IOSToXboxControllerMapping[16]] = ExGamepad.leftThumbstick.up;
CurrentStates[IOSToXboxControllerMapping[17]] = ExGamepad.leftThumbstick.down;
CurrentStates[IOSToXboxControllerMapping[18]] = ExGamepad.leftThumbstick.left;
CurrentStates[IOSToXboxControllerMapping[19]] = ExGamepad.leftThumbstick.right;
CurrentStates[IOSToXboxControllerMapping[20]] = ExGamepad.rightThumbstick.up;
CurrentStates[IOSToXboxControllerMapping[21]] = ExGamepad.rightThumbstick.down;
CurrentStates[IOSToXboxControllerMapping[22]] = ExGamepad.rightThumbstick.left;
CurrentStates[IOSToXboxControllerMapping[23]] = ExGamepad.rightThumbstick.right;
}
else if (Controller.gamepad != nil)
{
GCGamepad* Gamepad = Controller.gamepad;
/** Get the current state of all buttons */
CurrentStates[IOSToXboxControllerMapping[0]] = Gamepad.buttonA.pressed;
CurrentStates[IOSToXboxControllerMapping[1]] = Gamepad.buttonB.pressed;
CurrentStates[IOSToXboxControllerMapping[2]] = Gamepad.buttonX.pressed;
CurrentStates[IOSToXboxControllerMapping[3]] = Gamepad.buttonY.pressed;
CurrentStates[IOSToXboxControllerMapping[4]] = Gamepad.leftShoulder.pressed;
CurrentStates[IOSToXboxControllerMapping[5]] = Gamepad.rightShoulder.pressed;
CurrentStates[IOSToXboxControllerMapping[6]] = false;
CurrentStates[IOSToXboxControllerMapping[7]] = false;
CurrentStates[IOSToXboxControllerMapping[8]] = false;
CurrentStates[IOSToXboxControllerMapping[9]] = false;
CurrentStates[IOSToXboxControllerMapping[10]] = false;
CurrentStates[IOSToXboxControllerMapping[11]] = false;
CurrentStates[IOSToXboxControllerMapping[12]] = Gamepad.dpad.up.pressed;
CurrentStates[IOSToXboxControllerMapping[13]] = Gamepad.dpad.down.pressed;
CurrentStates[IOSToXboxControllerMapping[14]] = Gamepad.dpad.left.pressed;
CurrentStates[IOSToXboxControllerMapping[15]] = Gamepad.dpad.right.pressed;
CurrentStates[IOSToXboxControllerMapping[16]] = false;
CurrentStates[IOSToXboxControllerMapping[17]] = false;
CurrentStates[IOSToXboxControllerMapping[18]] = false;
CurrentStates[IOSToXboxControllerMapping[19]] = false;
CurrentStates[IOSToXboxControllerMapping[20]] = false;
CurrentStates[IOSToXboxControllerMapping[21]] = false;
CurrentStates[IOSToXboxControllerMapping[22]] = false;
CurrentStates[IOSToXboxControllerMapping[23]] = false;
}
const double CurrentTime = FPlatformTime::Seconds();
/** For each button check against the previous state and send the correct message if any */
for (int32 ButtonIndex = 0; ButtonIndex < MAX_NUM_IOS_CONTROLLER_BUTTONS; ++ButtonIndex)
{
if(CurrentStates[ButtonIndex] != ControllerState.ButtonStates[ButtonIndex])
{
if(CurrentStates[ButtonIndex])
{
MessageHandler->OnControllerButtonPressed(Buttons[ButtonIndex], ControllerState.ControllerId, false);
}
else
{
MessageHandler->OnControllerButtonReleased(Buttons[ButtonIndex], ControllerState.ControllerId, false);
}
if(CurrentStates[ButtonIndex] == true)
{
/** this button was pressed - set the button's NextRepeatTime to the InitialButtonRepeatDelay */
ControllerState.NextRepeatTime[ButtonIndex] = CurrentTime + InitialButtonRepeatDelay;
}
}
else if(CurrentStates[ButtonIndex] == true && ControllerState.NextRepeatTime[ButtonIndex] <= CurrentTime)
{
MessageHandler->OnControllerButtonPressed(Buttons[ButtonIndex], ControllerState.ControllerId, true);
/** set the button's NextRepeatTime to the ButtonRepeatDelay */
ControllerState.NextRepeatTime[ButtonIndex] = CurrentTime + ButtonRepeatDelay;
}
/** Update the state for next time */
ControllerState.ButtonStates[ButtonIndex] = CurrentStates[ButtonIndex];
}
}
}
bNeedsControllerStateUpdate = false;
#endif
}
void FIOSGamepad::SetMessageHandler(const TSharedRef<FGenericApplicationMessageHandler>&InMessageHandler)
{
MessageHandler = InMessageHandler;
}
bool FIOSGamepad::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar)
{
return false;
}
void FIOSGamepad::SetChannelValue (int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value)
{
}
void FIOSGamepad::SetChannelValues (int32 ControllerId, const FForceFeedbackValues &values)
{
}
void FIOSGamepad::OnControllerConnected ()
{
for(int32 ControllerIndex=0; ControllerIndex < FMath::Min<int32>(MAX_NUM_IOS_CONTROLLERS, [[GCController controllers] count]); ++ControllerIndex)
{
[GCController controllers][ControllerIndex].playerIndex = (GCControllerPlayerIndex)ControllerIndex;
}
this->bNeedsControllerStateUpdate = true;
}
void FIOSGamepad::OnControllerDisconnected ()
{
this->bNeedsControllerStateUpdate = true;
}
/** End of FIOSGamepad class */