internal async Task Setup(uint pktVersion)
{
_currentTask = new TaskCompletionSource <bool>();
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatConfReset(outReport, pktVersion);
// Send the output report asynchronously
_devState = DevState.ResetSend;
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Reset PKT");
}
Task <bool> task = _currentTask.Task;
Task taskDone = await Task.WhenAny(task, Task.Delay(1000));
if (taskDone != task)
{
throw new YAPI_Exception(YAPI.IO_ERROR, "Device does not respond to reset");
}
}
public static Task <DevInfo> CheckDeviceAsync(Service svc, int devId)
{
DevState lastKnownState = null;
Task.Run(() => { lastKnownState = svc.GetKnownDevState(devId); });
return(Task.Run(() => {
DevAddr addr = svc.GetDevAddr(devId);
DevReport devReport = svc.GetCurrDevReport(addr);
return new DevInfo(lastKnownState, devReport);
}));
}
public YUSBDevice(YUSBWatcher watcher, YUSBHub hub, HidDevice hid, DeviceInformation info)
{
_watcher = watcher;
_hub = hub;
_yctx = hub._yctx;
Hid = hid;
Info = info;
hid.InputReportReceived += OnInputReportEvent;
_devState = DevState.Detected;
_pktAckDelay = 0;
}
private async Task sendRequest(byte[] request, YGenericHub.RequestAsyncResult asyncResult, object asyncContext)
{
int pos = 0;
if (_currentRequest != null)
{
await _currentRequest.GetResponse();
}
//Debug.WriteLine(string.Format("{0}:Check last request is sent", Environment.CurrentManagedThreadId));
_currentRequest = new YRequest(request, asyncResult, asyncContext, 10000);
while (pos < request.Length)
{
if (_hid == null)
{
_devState = DevState.IOError;
_currentRequest = null;
throw new YAPI_Exception(YAPI.IO_ERROR, "USB device has been stopped");
}
// construct a HID output report to send to the device
HidOutputReport outReport;
try {
outReport = _hid.CreateOutputReport();
} catch (Exception ex) {
_devState = DevState.IOError;
_currentRequest = null;
throw new YAPI_Exception(YAPI.IO_ERROR, "Error during CreateOutputReport():" + ex.Message);
}
int size = YUSBPkt.imm_FormatTCP(outReport, request, pos, true);
// Send the output report asynchronously
uint u;
try {
u = await _hid.SendOutputReportAsync(outReport);
} catch (Exception ex) {
_devState = DevState.IOError;
_currentRequest = null;
throw new YAPI_Exception(YAPI.IO_ERROR, "Error during SendOutputReportAsync():" + ex.Message);
}
if (u != 65)
{
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
return;
}
pos += size;
}
//Debug.WriteLine(string.Format("{0}:sent", Environment.CurrentManagedThreadId));
}
//get dev state
public DevState getState()
{
DevState state = new DevState();
state.type = typeData.name;
state.exp = exp;
state.lvl = lvl;
state.energy = energy;
state.activity = currActivity;
return(state);
}
//set dev state
public void setState(DevState state) //set ups a dev using all the state from a dev
{
// <-- set type here
//startUp(typeData);
for (int i = 1; i < state.lvl; i++)
{
levelUp();
}
exp = state.exp;
energy = state.energy;
currActivity = state.activity;
energyFactor = updateEnergyFactor();
}
private async Task checkMetaUTC()
{
if (_lastMetaUTC + META_UTC_DELAY < YAPI.GetTickCount())
{
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatMetaUTC(outReport, true);
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT");
}
_lastMetaUTC = YAPI.GetTickCount();
}
}
internal async Task Start(byte pktAckDelay)
{
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
//("Activate USB pkt ack (%dms)\n", dev->pktAckDelay);
YUSBPkt.imm_FormatConfStart(outReport, 1, pktAckDelay);
// Send the output report asynchronously
_devState = DevState.StartSend;
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT");
}
}
/// <summary>
/// 获取屏幕上所有音频和视频设备
/// </summary>
public string GetVideoAndAudioDev()
{
string result = "";
DevState state = DevState.None;
VideoAndAudioDev devs = new VideoAndAudioDev();
string devName = string.Empty;
MepgHelper.ExecVideoCommand(VideoAndAudioList,
(sender, e) =>
{
state = MepgHelper.GetDevId(e.Data, state, ref devs, ref devName);
},
(sender, e) =>
{
_events.Publish(new DevListMessage {
Data = devs
}, (t) => { Task.Factory.StartNew(t); });
});
return(result);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.F1))
{
if (state == DevState.Test)
{
state = DevState.Debug;
}
else
{
state = DevState.Test;
}
}
if (source.isPlaying && SceneManager.GetActiveScene().buildIndex != 0 && SceneManager.GetActiveScene().buildIndex != 14)
{
source.Stop();
}
else if (!source.isPlaying && (SceneManager.GetActiveScene().buildIndex == 0 || SceneManager.GetActiveScene().buildIndex == 14))
{
source.Play();
}
}
public static DevState GetDevId(string msg, DevState state, ref VideoAndAudioDev dev, ref string devName)
{
if (!string.IsNullOrWhiteSpace(msg))
{
if (msg.Contains(VideoDevConst))
{
state = DevState.VideoState;
}
else if (msg.Contains(AudioStateConst))
{
state = DevState.AudioState;
}
else if (msg.Contains(DevIdConst))
{
string devId = msg.Substring(msg.IndexOf(DevIdConst), msg.Length - msg.IndexOf(DevIdConst)).Replace(DevIdConst, "").Replace("\"", "").Trim();
switch (state)
{
case DevState.VideoState:
dev.Videos.Add(new VideoDev()
{
DevId = devId, DevName = EncoderHelper.ASCIToUtf8(devName)
});
break;
case DevState.AudioState:
dev.Audios.Add(new AudioDev()
{
DevId = devId, DevName = EncoderHelper.ASCIToUtf8(devName)
});
break;
}
}
devName = msg;
}
return(state);
}
private void imm_handleNotifcation(YPktStreamHead ystream)
{
string functionId;
int firstByte = ystream.imm_GetByte(0);
bool isV2 = ystream.StreamType == YGenericHub.YSTREAM_NOTICE_V2;
if (isV2 || firstByte <= NOTIFY_1STBYTE_MAXTINY || firstByte >= NOTIFY_1STBYTE_MINSMALL)
{
int funcvalType = (firstByte >> NOTIFY_V2_TYPE_OFS) & NOTIFY_V2_TYPE_MASK;
int funydx = firstByte & NOTIFY_V2_FUNYDX_MASK;
YPEntry ypEntry = imm_getYPEntryFromYdx(funydx);
if (ypEntry != null)
{
if (ypEntry.Index == funydx)
{
if (funcvalType == YGenericHub.NOTIFY_V2_FLUSHGROUP)
{
// not yet used by devices
}
else
{
if ((firstByte & NOTIFY_V2_IS_SMALL_FLAG) != 0)
{
// added on 2015-02-25, remove code below when confirmed dead code
throw new YAPI_Exception(YAPI.IO_ERROR, "Hub Should not fwd notification");
}
int len = (int)ystream.Len;
byte[] data = new byte[len];
ystream.imm_CopyData(data, 0);
string funcval = YGenericHub.imm_decodePubVal(funcvalType, data, 1, len - 1);
_hub.imm_handleValueNotification(SerialNumber, ypEntry.FuncId, funcval);
}
}
}
}
else
{
string serial = ystream.imm_GetString(0, YAPI.YOCTO_SERIAL_LEN);
if (SerialNumber == null)
{
SerialNumber = serial;
}
uint p = YAPI.YOCTO_SERIAL_LEN;
int type = ystream.imm_GetByte(p++);
switch (type)
{
case NOTIFY_PKT_NAME:
_logicalname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN);
_beacon = ystream.imm_GetByte(p + YAPI.YOCTO_LOGICAL_LEN);
break;
case NOTIFY_PKT_PRODNAME:
_product = ystream.imm_GetString(p, YAPI.YOCTO_PRODUCTNAME_LEN);
break;
case NOTIFY_PKT_CHILD:
break;
case NOTIFY_PKT_FIRMWARE:
_firmware = ystream.imm_GetString(p, YAPI.YOCTO_FIRMWARE_LEN);
p += YAPI.YOCTO_FIRMWARE_LEN;
p += 2;
_deviceid = (ushort)(ystream.imm_GetByte(p) + (ystream.imm_GetByte(p + 1) << 8));
break;
case NOTIFY_PKT_FUNCNAME:
functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN);
p += YAPI.YOCTO_FUNCTION_LEN;
string funcname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN);
if (!_usbYP.ContainsKey(functionId))
{
_usbYP[functionId] = new YPEntry(serial, functionId, YPEntry.BaseClass.Function);
}
_usbYP[functionId].LogicalName = funcname;
break;
case NOTIFY_PKT_FUNCVAL:
functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN);
p += YAPI.YOCTO_FUNCTION_LEN;
string funcval = ystream.imm_GetString(p, YAPI.YOCTO_PUBVAL_SIZE);
_hub.imm_handleValueNotification(serial, functionId, funcval);
break;
case NOTIFY_PKT_STREAMREADY:
_devState = DevState.StreamReadyReceived;
_wp = new WPEntry(_logicalname, _product, _deviceid, "", _beacon, SerialNumber);
_yctx._Log("Device " + SerialNumber + " ready.\n");
_currentTask.SetResult(true);
break;
case NOTIFY_PKT_LOG:
//FIXME: handle log notification
break;
case NOTIFY_PKT_FUNCNAMEYDX:
functionId = ystream.imm_GetString(p, YAPI.YOCTO_FUNCTION_LEN - 1);
p += YAPI.YOCTO_FUNCTION_LEN - 1;
byte funclass = ystream.imm_GetByte(p++);
funcname = ystream.imm_GetString(p, YAPI.YOCTO_LOGICAL_LEN);
p += YAPI.YOCTO_LOGICAL_LEN;
byte funydx = ystream.imm_GetByte(p);
if (!_usbYP.ContainsKey(functionId))
{
_usbYP[functionId] = new YPEntry(serial, functionId, YPEntry.BaseClass.forByte(funclass));
}
// update ydx
_usbYP[functionId].Index = funydx;
_usbYP[functionId].LogicalName = funcname;
break;
case NOTIFY_PKT_PRODINFO:
break;
default:
//fixme: Find why this happening on my dev computer
throw new YAPI_Exception(YAPI.IO_ERROR, "Invalid Notification");
}
}
}
internal async Task streamHandler(List <YPktStreamHead> streams)
{
foreach (YPktStreamHead s in streams)
{
uint streamType = s.StreamType;
switch (streamType)
{
case YGenericHub.YSTREAM_NOTICE:
case YGenericHub.YSTREAM_NOTICE_V2:
imm_handleNotifcation(s);
break;
case YGenericHub.YSTREAM_TCP_CLOSE:
case YGenericHub.YSTREAM_TCP:
if (_devState != DevState.StreamReadyReceived || _currentRequest == null)
{
continue;
}
_currentRequest.imm_AddIncommingData(s);
if (streamType == YGenericHub.YSTREAM_TCP_CLOSE)
{
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatTCP(outReport, null, 0, true);
// Send the output report asynchronously
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
return;
}
_currentRequest.imm_Close();
}
break;
case YGenericHub.YSTREAM_EMPTY:
break;
case YGenericHub.YSTREAM_REPORT:
if (_devState == DevState.StreamReadyReceived)
{
imm_handleTimedNotification(s);
}
break;
case YGenericHub.YSTREAM_REPORT_V2:
if (_devState == DevState.StreamReadyReceived)
{
handleTimedNotificationV2(s);
}
break;
default:
_yctx._Log("drop unknown ystream:" + s);
break;
}
}
}
internal async void OnInputReportEvent(HidDevice sender, HidInputReportReceivedEventArgs args)
{
if (_devState == DevState.Detected || _devState == DevState.IOError)
{
// drop all packet until reset has been sent
return;
}
try {
byte[] bb = args.Report.Data.ToArray();
long ofs = 1; //skip first byte that is not part of the packet
List <YPktStreamHead> streams = new List <YPktStreamHead>();
while (ofs < bb.Length)
{
YPktStreamHead s = YPktStreamHead.imm_Decode(ofs, bb);
if (s == null)
{
break;
}
//Debug.WriteLine(s.ToString());
streams.Add(s);
ofs += s.Len + 2;
}
YPktStreamHead streamHead = streams[0];
switch (_devState)
{
case DevState.ResetSend:
if (streamHead.PktType != YUSBPkt.YPKT_CONF || streamHead.StreamType != YUSBPkt.USB_CONF_RESET)
{
return;
}
byte low = streamHead.imm_GetByte(0);
uint hig = streamHead.imm_GetByte(1);
uint devapi = (hig << 8) + low;
_devVersion = devapi;
if (imm_CheckVersionCompatibility(devapi) < 0)
{
return;
}
await Start(_pktAckDelay);
break;
case DevState.StartSend:
if (streamHead.PktType != YUSBPkt.YPKT_CONF || streamHead.StreamType != YUSBPkt.USB_CONF_START)
{
return;
}
if (_devVersion >= YUSBPkt.YPKT_USB_VERSION_BCD)
{
_pktAckDelay = streamHead.imm_GetByte(1);
}
else
{
_pktAckDelay = 0;
}
_lastpktno = streamHead.PktNumber;
_devState = DevState.StartReceived;
break;
case DevState.StreamReadyReceived:
case DevState.StartReceived:
if (_devState == DevState.StreamReadyReceived || _devState == DevState.StartReceived)
{
if (_pktAckDelay > 0 && _lastpktno == streamHead.PktNumber)
{
//late retry : drop it since we already have the packet.
return;
}
uint expectedPktNo = (_lastpktno + 1) & 7;
if (streamHead.PktNumber != expectedPktNo)
{
String message = "Missing packet (look of pkt " + expectedPktNo + " but get " + streamHead.PktNumber + ")";
_yctx._Log(message + "\n");
_yctx._Log("Set YAPI.RESEND_MISSING_PKT on YAPI.InitAPI()\n");
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
return;
}
_lastpktno = streamHead.PktNumber;
await streamHandler(streams);
await checkMetaUTC();
}
break;
default:
return;
}
} catch (YAPI_Exception ex) {
_yctx._Log(ex.Message + "\n");
_yctx._Log("Set YAPI.RESEND_MISSING_PKT on YAPI.InitAPI()\n");
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
if (_currentTask != null)
{
_currentTask.SetException(ex);
}
}
}
public DevInfo(DevState state, DevReport report)
{
}
