コード例 #1
0
ファイル: App.cpp プロジェクト: Figuration/PSMoveService
void App::onClientPSMoveResponse(
    const ClientPSMoveAPI::ResponseMessage *response)
{
    ClientPSMoveAPI::t_request_id request_id= response->request_id;
    const PSMoveProtocol::Response *protocol_response = GET_PSMOVEPROTOCOL_RESPONSE(response->opaque_response_handle);
    PSMoveProtocol::Response_ResponseType protocol_response_type= protocol_response->type();
    const std::string& protocol_response_type_name = PSMoveProtocol::Response_ResponseType_Name(protocol_response_type);

    // All responses should have been handled by a response handler
    Log_ERROR("App::onClientPSMoveResponse", "Unhandled response type:%s (request id: %d)!", 
        protocol_response_type_name.c_str(), request_id);
}
コード例 #2
0
void AppStage_ComputeTrackerPoses::handle_controller_list_response(
    const ClientPSMoveAPI::ResponseMessage *response_message,
    void *userdata)
{
	const PSMoveProtocol::Response *response = GET_PSMOVEPROTOCOL_RESPONSE(response_message->opaque_response_handle);
	const PSMoveProtocol::Request *request = GET_PSMOVEPROTOCOL_REQUEST(response_message->opaque_request_handle);
	
    AppStage_ComputeTrackerPoses *thisPtr = static_cast<AppStage_ComputeTrackerPoses *>(userdata);

    const ClientPSMoveAPI::eClientPSMoveResultCode ResultCode = response_message->result_code;

    switch (ResultCode)
    {
    case ClientPSMoveAPI::_clientPSMoveResultCode_ok:
        {
            assert(response_message->payload_type == ClientPSMoveAPI::_responsePayloadType_ControllerList);
            const ClientPSMoveAPI::ResponsePayload_ControllerList *controller_list = 
                &response_message->payload.controller_list;			

			if (thisPtr->m_bSkipCalibration)
			{
				bool bStartedAnyControllers = false;

				for (int list_index = 0; list_index < controller_list->count; ++list_index)
				{
					if (controller_list->controller_type[list_index] == ClientControllerView::PSMove ||
						controller_list->controller_type[list_index] == ClientControllerView::PSDualShock4)
					{
						int trackedControllerId = controller_list->controller_id[list_index];
						const auto &protocolControllerResponse = response->result_controller_list().controllers(list_index);
						const PSMoveTrackingColorType trackingColorType=
							static_cast<PSMoveTrackingColorType>(protocolControllerResponse.tracking_color_type());

						thisPtr->request_start_controller_stream(trackedControllerId, list_index, trackingColorType);
						bStartedAnyControllers = true;
					}
				}

				if (!bStartedAnyControllers)
				{
					thisPtr->setState(AppStage_ComputeTrackerPoses::failedControllerListRequest);
				}
			}
			else
			{
				int trackedControllerId = thisPtr->m_overrideControllerId;
				int trackedControllerListIndex = -1;
				PSMoveTrackingColorType trackingColorType;

				if (trackedControllerId == -1)
				{
					for (int list_index = 0; list_index < controller_list->count; ++list_index)
					{
						if (controller_list->controller_type[list_index] == ClientControllerView::PSMove ||
							controller_list->controller_type[list_index] == ClientControllerView::PSDualShock4)
						{
							const auto &protocolControllerResponse = response->result_controller_list().controllers(list_index);

							trackingColorType = static_cast<PSMoveTrackingColorType>(protocolControllerResponse.tracking_color_type());
							trackedControllerId = controller_list->controller_id[list_index];
							trackedControllerListIndex = list_index;
							break;
						}
					}
				}

				if (trackedControllerId != -1)
				{
					thisPtr->request_start_controller_stream(trackedControllerId, trackedControllerListIndex, trackingColorType);
				}
				else
				{
					thisPtr->setState(AppStage_ComputeTrackerPoses::failedControllerListRequest);
				}
			}
        } break;

    case ClientPSMoveAPI::_clientPSMoveResultCode_error:
    case ClientPSMoveAPI::_clientPSMoveResultCode_canceled:
        {
            thisPtr->setState(AppStage_ComputeTrackerPoses::failedControllerListRequest);
        } break;
    }
}
コード例 #3
0
void AppStage_ControllerSettings::handle_controller_list_response(
    const ClientPSMoveAPI::ResponseMessage *response_message,
    void *userdata)
{
    AppStage_ControllerSettings *thisPtr= static_cast<AppStage_ControllerSettings *>(userdata);

    const ClientPSMoveAPI::eClientPSMoveResultCode ResultCode = response_message->result_code;
    const ClientPSMoveAPI::t_response_handle response_handle = response_message->opaque_response_handle;

    switch(ResultCode)
    {
        case ClientPSMoveAPI::_clientPSMoveResultCode_ok:
        {
            const PSMoveProtocol::Response *response= GET_PSMOVEPROTOCOL_RESPONSE(response_handle);

            thisPtr->m_hostSerial = response->result_controller_list().host_serial();

            for (int controller_index= 0; controller_index < response->result_controller_list().controllers_size(); ++controller_index)
            {
                const auto &ControllerResponse= response->result_controller_list().controllers(controller_index);

                AppStage_ControllerSettings::ControllerInfo ControllerInfo;

                ControllerInfo.ControllerID= ControllerResponse.controller_id();

                switch(ControllerResponse.controller_type())
                {
                case PSMoveProtocol::PSMOVE:
                    ControllerInfo.ControllerType= AppStage_ControllerSettings::PSMove;
                    break;
                case PSMoveProtocol::PSNAVI:
                    ControllerInfo.ControllerType= AppStage_ControllerSettings::PSNavi;
                    break;
                default:
                    assert(0 && "unreachable");
                }

                ControllerInfo.TrackingColorType = 
                    static_cast<PSMoveTrackingColorType>(ControllerResponse.tracking_color_type());
                ControllerInfo.DevicePath= ControllerResponse.device_path();
                ControllerInfo.DeviceSerial= ControllerResponse.device_serial();
                ControllerInfo.AssignedHostSerial= ControllerResponse.assigned_host_serial();
                ControllerInfo.PairedToHost=
                    ControllerResponse.assigned_host_serial().length() > 0 && 
                    ControllerResponse.assigned_host_serial() == thisPtr->m_hostSerial;

                // Add the controller to the appropriate connection list
                switch (ControllerResponse.connection_type())
                {
                case PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_BLUETOOTH:
                    thisPtr->m_bluetoothControllerInfos.push_back(ControllerInfo);
                    break;
                case PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_USB:
                    thisPtr->m_usbControllerInfos.push_back(ControllerInfo);
                    break;
                default:
                    assert(0 && "unreachable");
                }
            }

            thisPtr->m_selectedControllerIndex= (thisPtr->m_bluetoothControllerInfos.size() > 0) ? 0 : -1;
            thisPtr->m_menuState= AppStage_ControllerSettings::idle;
        } break;

        case ClientPSMoveAPI::_clientPSMoveResultCode_error:
        case ClientPSMoveAPI::_clientPSMoveResultCode_canceled:
        { 
            thisPtr->m_menuState= AppStage_ControllerSettings::failedControllerListRequest;
        } break;
    }
}