/// <summary> /// Scans the dveice. /// </summary> void ScanDveice() { var mBluetoothLeScanner = bluetoothAdapter.Call <AndroidJavaObject>("getBluetoothLeScanner"); ScanCallback scanCallback = new ScanCallback(); AndroidJavaObject wfzScanCallback = new AndroidJavaObject("com.ridk.unityextension.RidkScanCallback"); scanCallback.onScanResultDelegate = (t, r) => { if (r == null) { return; } var bluetoothDevice = r.Call <AndroidJavaObject>("getDevice"); var deviceName = bluetoothDevice.Call <string>("getName"); var deviceAddress = bluetoothDevice.Call <string>("getAddress"); Debug.Log("扫描到设备:" + deviceName + "地址:" + deviceAddress); if (deviceName == "CAD") { if (buetoothGatt == null) { ConnectGatt(bluetoothDevice); mBluetoothLeScanner.Call("stopScan", wfzScanCallback); } } }; wfzScanCallback.Call("AddUnityCallback", scanCallback); mBluetoothLeScanner.Call("startScan", wfzScanCallback); }
void InitializeScanner() { if (_adapter == null) { return; } // initialize scanner var sb = new ScanSettings.Builder() .SetCallbackType(ScanCallbackType.AllMatches) .SetScanMode(ScanMode.LowLatency); if (Build.VERSION.SdkInt >= BuildVersionCodes.M) { sb = sb.SetMatchMode(BluetoothScanMatchMode.Aggressive).SetNumOfMatches(1); } _scanSettings = sb.Build(); sb.SetReportDelay(1000); _scanSettingsBatch = sb.Build(); _scanner = _adapter.BluetoothLeScanner; _scanCallback = new ScanCallbackImpl(this); _scanCallbackBatch = new BatchScanCallbackImpl(); }
public void StartScanning(Context context, TracingInformation tracingInformation) { if (!Initialized) { _logger.LogError("Scanner - Starting failed - not initialized."); return; } try { _tracingInformation = tracingInformation; _logger.LogDebug($"Scanner - Starting for service {_tracingInformation.ServiceId}."); if (_scanCallback == null) { _scanCallback = new BtScanCallback(context, _manager, tracingInformation); } System.Threading.Tasks.Task.Run(() => { _leScanner.StartScan(BuildScanFilters(_tracingInformation), BuildScanSettings(), _scanCallback); }).FireAndForget(); Covi.Features.BluetoothTracing.TracingState.Instance.SetScanningState(true); } catch (Exception ex) { _logger.LogError(ex, "Scanner - Starting failed."); } }
private void InitScanner() { if (IsAfterLollipop && !(Filters?.Any() ?? false)) { if (Filters == null) { Filters = new List <ScanFilter>(); } else { Filters.Clear(); } Filters.Add(new ScanFilter.Builder().SetServiceUuid(BcoreUuid.BcoreScanUuid).Build()); } if (IsAfterLollipop && ScanSettings == null) { ScanSettings = new ScanSettings.Builder().SetScanMode(ScanMode.Balanced).Build(); } if (IsAfterLollipop && Callback == null) { Callback = new ScanCallback(this); } if (!IsAfterLollipop && LeCallback == null) { LeCallback = new LeScanCallback(this); } }
public Bluetooth(Context context) { _manager = (BluetoothManager)context.GetSystemService(Class.FromType(typeof(BluetoothManager))); _scanner = _manager.Adapter.BluetoothLeScanner; _scanCallback = new ScanCallback(this); _identifier = Injection.GetDeviceId(context); }
/// <summary> /// Scan the CEC bus and get active devices. /// </summary> public List <CecLogicalAddress> Scan() { List <CecLogicalAddress> devices = new List <CecLogicalAddress>(10); ScanCallback cb = i => devices.Add(i); CecManager_Scan(ptr, cb); return(devices); }
public async Task Cancel() { LastScanResult = null; await StopScanningAsync(); ScanCallback?.Invoke(null); }
public BES( ) { var btManager = (BluetoothManager)Application.Context.GetSystemService(Context.BluetoothService); _btadapter = btManager.Adapter; _filt = Pega_filtros(); _sets = new ScanSettings.Builder().SetScanMode(ScanMode.LowLatency).Build(); _btcallback = new BLECallback(_btd, _filt, _sets); _error = "-"; }
protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); global::Xamarin.Forms.Forms.Init(this, bundle); LoadApplication(new App()); ScanCallback = new ScanCallbackClass() { OnSuccess = OnSuccess }; ActivateMiBand(); }
public BluetoothConnector() { this.context = Android.App.Application.Context; bluetoothManager = (BluetoothManager)context.GetSystemService(Context.BluetoothService); bluetoothAdapter = bluetoothManager.Adapter; bluetoothScanner = bluetoothManager.Adapter.BluetoothLeScanner; bluetoothReceiver = new BluetoothReceiver(devicesResults, macAddressMapping); context.RegisterReceiver(bluetoothReceiver, new IntentFilter(BluetoothDevice.ActionFound)); context.RegisterReceiver(bluetoothReceiver, new IntentFilter(BluetoothDevice.ExtraRssi)); this.scanThread = new Thread(Scan); this.scanCallback = new BluetoothScanCallback(devicesResults, macAddressMapping); }
public void StopScanning() { if (!Initialized) { return; } _leScanner.StopScan(_scanCallback); _scanCallback?.Dispose(); _scanCallback = null; Covi.Features.BluetoothTracing.TracingState.Instance.SetScanningState(false); }
public ScanCommand ( ScanPolicy policy, string ns, string setName, ScanCallback callback, string[] binNames, ulong taskId ) : base(true) { this.policy = policy; this.ns = ns; this.setName = setName; this.callback = callback; this.binNames = binNames; this.taskId = taskId; }
public ScanCommand( Node node, ScanPolicy policy, string ns, string setName, ScanCallback callback, string[] binNames, long taskId ) : base(node, true) { this.policy = policy; this.ns = ns; this.setName = setName; this.callback = callback; this.binNames = binNames; this.taskId = taskId; }
public ScanCommand ( ScanPolicy policy, string ns, string setName, ScanCallback callback, string[] binNames, ulong taskId, ulong clusterKey, bool first ) : base(ns, clusterKey, first) { this.policy = policy; this.setName = setName; this.callback = callback; this.binNames = binNames; this.taskId = taskId; }
public static void stopScan(ScanCallback callback) { BluetoothAdapter adapter = BluetoothAdapter.DefaultAdapter; if (adapter == null) { Log.Debug(tag, "BluetoothAdapter is null"); } BluetoothLeScanner scaner = adapter.BluetoothLeScanner; if (scaner == null) { Log.Debug(tag, "BluetoothLeScanner is null"); } scaner.StopScan(callback); }
public ScanCommand ( Cluster cluster, Node node, ScanPolicy scanPolicy, string ns, string setName, string[] binNames, ScanCallback callback, ulong taskId, ulong clusterKey, bool first ) : base(cluster, scanPolicy, node, ns, clusterKey, first) { this.scanPolicy = scanPolicy; this.setName = setName; this.binNames = binNames; this.callback = callback; this.taskId = taskId; }
public ScanPartitionCommand ( Cluster cluster, ScanPolicy scanPolicy, string ns, string setName, string[] binNames, ScanCallback callback, ulong taskId, PartitionTracker tracker, NodePartitions nodePartitions ) : base(cluster, scanPolicy, nodePartitions.node, ns, tracker.socketTimeout, tracker.totalTimeout) { this.scanPolicy = scanPolicy; this.setName = setName; this.binNames = binNames; this.callback = callback; this.taskId = taskId; this.tracker = tracker; this.nodePartitions = nodePartitions; }
public WifiScanConnectWrap(NativeWifiManager wifiManager) { nativeWifiManager = wifiManager; mScanCallback = new ScanCallback(); }
//------------------------------------------------------- // Scan Operations //------------------------------------------------------- /// <summary> /// Read all records in specified namespace and set. If the policy's /// concurrentNodes is specified, each server node will be read in /// parallel. Otherwise, server nodes are read in series. /// <para> /// This call will block until the scan is complete - callbacks are made /// within the scope of this call. /// </para> /// </summary> /// <param name="policy">scan configuration parameters, pass in null for defaults</param> /// <param name="ns">namespace - equivalent to database name</param> /// <param name="setName">optional set name - equivalent to database table</param> /// <param name="callback">read callback method - called with record data</param> /// <param name="binNames"> /// optional bin to retrieve. All bins will be returned if not specified. /// Aerospike 2 servers ignore this parameter. /// </param> /// <exception cref="AerospikeException">if scan fails</exception> public void ScanAll(ScanPolicy policy, string ns, string setName, ScanCallback callback, params string[] binNames) { if (policy == null) { policy = scanPolicyDefault; } Node[] nodes = cluster.Nodes; if (nodes.Length == 0) { throw new AerospikeException(ResultCode.SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty."); } if (policy.concurrentNodes) { Executor executor = new Executor(nodes.Length); ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); foreach (Node node in nodes) { ScanCommand command = new ScanCommand(node, policy, ns, setName, callback, binNames, taskId); executor.AddCommand(command); } executor.Execute(policy.maxConcurrentNodes); } else { foreach (Node node in nodes) { ScanNode(policy, node, ns, setName, callback, binNames); } } }
/// <summary> /// Read all records in specified namespace and set for one node only. /// The node is specified by name. /// <para> /// This call will block until the scan is complete - callbacks are made /// within the scope of this call. /// </para> /// </summary> /// <param name="policy">scan configuration parameters, pass in null for defaults</param> /// <param name="nodeName">server node name</param> /// <param name="ns">namespace - equivalent to database name</param> /// <param name="setName">optional set name - equivalent to database table</param> /// <param name="callback">read callback method - called with record data</param> /// <param name="binNames"> /// optional bin to retrieve. All bins will be returned if not specified. /// Aerospike 2 servers ignore this parameter. /// </param> /// <exception cref="AerospikeException">if scan fails</exception> public void ScanNode(ScanPolicy policy, string nodeName, string ns, string setName, ScanCallback callback, params string[] binNames) { Node node = cluster.GetNode(nodeName); ScanNode(policy, node, ns, setName, callback, binNames); }
static BluetoothLEScanner() { Current = new BluetoothLEScanner(); _scanCallback = new BluetoothLEScannerScanCallback(Current); }
/// <summary> /// Read all records in specified namespace and set for one node only. /// <para> /// This call will block until the scan is complete - callbacks are made /// within the scope of this call. /// </para> /// </summary> /// <param name="policy">scan configuration parameters, pass in null for defaults</param> /// <param name="node">server node</param> /// <param name="ns">namespace - equivalent to database name</param> /// <param name="setName">optional set name - equivalent to database table</param> /// <param name="callback">read callback method - called with record data</param> /// <param name="binNames"> /// optional bin to retrieve. All bins will be returned if not specified. /// Aerospike 2 servers ignore this parameter. /// </param> /// <exception cref="AerospikeException">if transaction fails</exception> public void ScanNode(ScanPolicy policy, Node node, string ns, string setName, ScanCallback callback, params string[] binNames) { if (policy == null) { policy = scanPolicyDefault; } ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); ScanCommand command = new ScanCommand(node, policy, ns, setName, callback, binNames, taskId); command.Execute(); }
public static void ScanPartitions(Cluster cluster, ScanPolicy policy, string ns, string setName, string[] binNames, ScanCallback callback, PartitionTracker tracker) { policy.Validate(); while (true) { ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); try { List <NodePartitions> list = tracker.AssignPartitionsToNodes(cluster, ns); if (policy.concurrentNodes && list.Count > 1) { Executor executor = new Executor(list.Count); foreach (NodePartitions nodePartitions in list) { ScanPartitionCommand command = new ScanPartitionCommand(cluster, policy, ns, setName, binNames, callback, taskId, tracker, nodePartitions); executor.AddCommand(command); } executor.Execute(policy.maxConcurrentNodes); } else { foreach (NodePartitions nodePartitions in list) { ScanPartitionCommand command = new ScanPartitionCommand(cluster, policy, ns, setName, binNames, callback, taskId, tracker, nodePartitions); command.Execute(); } } } catch (AerospikeException ae) { ae.Iteration = tracker.iteration; throw ae; } if (tracker.IsComplete(policy)) { // Scan is complete. return; } if (policy.sleepBetweenRetries > 0) { // Sleep before trying again. Util.Sleep(policy.sleepBetweenRetries); } } }
public bool ScanDirectory(string DirPrefix, ScanCallback Callback, BuildDBInfo UserData) { PInvoke.WIN32_FIND_DATA FindData; var DirIndice = (uint)Directories.Count - 1; var SearchString = DirPrefix + "*"; var FindHandle = PInvoke.FindFirstFile(SearchString, out FindData); if (FindHandle == PInvoke.INVALID_HANDLE_VALUE) { return(false); } do { UInt64 FileSize = ((FindData.nFileSizeHigh << 32) | FindData.nFileSizeLow); FileInfo Info = new FileInfo(FindData.cFileName, DirIndice, FileSize, FindData.dwFileAttributes); SafeFileHandle Handle = null; // DonLL't ever include '.L' and '..' if (Info.Name == "." || Info.Name == "..") { continue; } //Info.FullName = DirPrefix + Info.Name; Info.Clusters = 0; if (GetClusterInfo(Info, ref Handle)) { UInt64 TotalClusters = Info.Fragments.Aggregate <Extent, ulong>(0, (current, ext) => current + ext.Length); Info.Clusters = TotalClusters; } else { Info.Attributes.Unmovable = true; Info.Attributes.Process = false; } if (Info.Attributes.Process) { Info.Attributes.Process = ShouldProcess(Info.Attributes); } // Run the user-defined callback function var CallbackResult = Callback(ref Info, ref Handle, ref UserData); if (!Handle.IsInvalid && !Handle.IsClosed) { Handle.Close(); } if (!CallbackResult) { break; } // If directory, perform recursion if (Info.Attributes.Directory) { var Dir = GetDBDir(Info.DirIndice); Dir += Info.Name; Dir += "\\"; Directories.Add(Dir); ScanDirectory(Dir, Callback, UserData); } } while (PInvoke.FindNextFile(FindHandle, out FindData)); PInvoke.FindClose(FindHandle); return(false); }
public static void ScanNodes(Cluster cluster, ScanPolicy policy, string ns, string setName, string[] binNames, ScanCallback callback, Node[] nodes) { policy.Validate(); // Detect cluster migrations when performing scan. ulong taskId = RandomShift.ThreadLocalInstance.NextLong(); ulong clusterKey = policy.failOnClusterChange ? QueryValidate.ValidateBegin(nodes[0], ns) : 0; bool first = true; if (policy.concurrentNodes && nodes.Length > 1) { Executor executor = new Executor(nodes.Length); foreach (Node node in nodes) { ScanCommand command = new ScanCommand(cluster, node, policy, ns, setName, binNames, callback, taskId, clusterKey, first); executor.AddCommand(command); first = false; } executor.Execute(policy.maxConcurrentNodes); } else { foreach (Node node in nodes) { ScanCommand command = new ScanCommand(cluster, node, policy, ns, setName, binNames, callback, taskId, clusterKey, first); command.Execute(); first = false; } } }
public bool startScan(ScanCallback callBack) { return(mWifiManager.startScan(callBack)); }
internal static void Scan(string ct, int ct_begIdx, int ct_endIdxExcl, ScanCallback scanCallback) { if (ct == null) { throw new ArgumentNullException(); } int iLast = ct_begIdx; while (true) { int i = ct.IndexOf('[', iLast, ct_endIdxExcl - iLast); if (i < 0) { break; } if (!scanCallback(iLast, i, 0)) { return; } int ii = i + 1; ScanCallbackFlags flags = 0; while (true) { ii = ct.IndexOf(']', ii, ct_endIdxExcl - ii); if (ii < 0) { throw new ArgumentException(); } if (ii + 1 == ct.Length || ct[ii + 1] != ']') { break; } flags |= ScanCallbackFlags.IsQuotedIdentifier_ContainsRightSquareBrackets; } if (!scanCallback(i + 1, ii, flags | ScanCallbackFlags.IsQuotedIdentifier)) { return; } iLast = ii + 1; } scanCallback(iLast, ct.Length, 0); }
private static extern void CecManager_Scan(IntPtr ptr, ScanCallback cb);
/////////////////////////////////////////////////////////////////////////////// // Public Functions, these are the essentials... /////////////////////////////////////////////////////////////////////////////// #region Public Functions... /// <summary> /// Our constructor... /// </summary> /// <param name="a_szManufacturer">Application manufacturer</param> /// <param name="a_szProductFamily">Application product family</param> /// <param name="a_szProductName">Name of the application</param> /// <param name="a_u16ProtocolMajor">TWAIN protocol major (doesn't have to match TWAINH.CS)</param> /// <param name="a_u16ProtocolMinor">TWAIN protocol minor (doesn't have to match TWAINH.CS)</param> /// <param name="a_u32SupportedGroups">Bitmask of DG_ flags</param> /// <param name="a_twcy">Country code for the application</param> /// <param name="a_szInfo">Info about the application</param> /// <param name="a_twlg">Language code for the application</param> /// <param name="a_u16MajorNum">Application's major version</param> /// <param name="a_u16MinorNum">Application's minor version</param> /// <param name="a_blUseLegacyDSM">Use the legacy DSM (like TWAIN_32.DLL)</param> /// <param name="a_blUseCallbacks">Use callbacks instead of Windows post message</param> /// <param name="a_deviceeventback">Function to receive device events</param> /// <param name="a_scancallback">Function to handle scanning</param> /// <param name="a_runinuithreaddelegate">Help us run in the GUI thread on Windows</param> /// <param name="a_intptrHwnd">window handle</param> public TWAIN ( string a_szManufacturer, string a_szProductFamily, string a_szProductName, ushort a_u16ProtocolMajor, ushort a_u16ProtocolMinor, uint a_u32SupportedGroups, TWCY a_twcy, string a_szInfo, TWLG a_twlg, ushort a_u16MajorNum, ushort a_u16MinorNum, bool a_blUseLegacyDSM, bool a_blUseCallbacks, DeviceEventCallback a_deviceeventback, ScanCallback a_scancallback, RunInUiThreadDelegate a_runinuithreaddelegate, IntPtr a_intptrHwnd ) { TW_IDENTITY twidentity; // Since we're using P/Invoke in this sample, the DLL // is implicitly loaded as we access it, so we can // never go lower than state 2... m_state = STATE.S2; // Register the caller's info... twidentity = default(TW_IDENTITY); twidentity.Manufacturer.Set(a_szManufacturer); twidentity.ProductFamily.Set(a_szProductFamily); twidentity.ProductName.Set(a_szProductName); twidentity.ProtocolMajor = a_u16ProtocolMajor; twidentity.ProtocolMinor = a_u16ProtocolMinor; twidentity.SupportedGroups = a_u32SupportedGroups; twidentity.Version.Country = a_twcy; twidentity.Version.Info.Set(a_szInfo); twidentity.Version.Language = a_twlg; twidentity.Version.MajorNum = a_u16MajorNum; twidentity.Version.MinorNum = a_u16MinorNum; m_twidentityApp = twidentity; m_twidentitylegacyApp = TwidentityToTwidentitylegacy(twidentity); m_twidentitymacosxApp = TwidentityToTwidentitymacosx(twidentity); m_deviceeventcallback = a_deviceeventback; m_scancallback = a_scancallback; m_runinuithreaddelegate = a_runinuithreaddelegate; m_intptrHwnd = a_intptrHwnd; // Placeholder for our DS identity... m_twidentityDs = default(TW_IDENTITY); m_twidentitylegacyDs = default(TW_IDENTITY_LEGACY); m_twidentitymacosxDs = default(TW_IDENTITY_MACOSX); // We'll normally do an automatic get of DAT.STATUS, but if we'd // like to turn it off, this is the variable to hit... m_blAutoDatStatus = true; // Our helper functions from the DSM... m_twentrypointdelegates = default(TW_ENTRYPOINT_DELEGATES); // Our events... m_autoreseteventCaller = new AutoResetEvent(false); m_autoreseteventThread = new AutoResetEvent(false); m_autoreseteventRollback = new AutoResetEvent(false); m_autoreseteventThreadStarted = new AutoResetEvent(false); m_lockTwain = new Object(); // Windows only... if (ms_platform == Platform.WINDOWS) { m_blUseLegacyDSM = a_blUseLegacyDSM; m_blUseCallbacks = a_blUseCallbacks; m_windowsdsmentrycontrolcallbackdelegate = WindowsDsmEntryCallbackProxy; } // Linux only... else if (ms_platform == Platform.LINUX) { m_blUseLegacyDSM = false; m_blUseCallbacks = true; m_linuxdsmentrycontrolcallbackdelegate = LinuxDsmEntryCallbackProxy; } // Mac OS X only... else if (ms_platform == Platform.MACOSX) { m_blUseLegacyDSM = false; m_blUseCallbacks = true; m_macosxdsmentrycontrolcallbackdelegate = MacosxDsmEntryCallbackProxy; } // Uh-oh, Log will throw an exception for us... else { TWAINWorkingGroup.Log.Assert("Unsupported platform..." + ms_platform); } // Activate our thread... if (m_threadTwain == null) { m_twaincommand = new TwainCommand(); m_threadTwain = new Thread(Main); m_threadTwain.Start(); if (!m_autoreseteventThreadStarted.WaitOne(5000)) { try { m_threadTwain.Abort(); m_threadTwain = null; } catch { // Log will throw an exception for us... TWAINWorkingGroup.Log.Assert("Failed to start the TWAIN background thread..."); } } } }
/// <summary> /// Read all records in specified namespace and set for one node only. /// <para> /// This call will block until the scan is complete - callbacks are made /// within the scope of this call. /// </para> /// </summary> /// <param name="policy">scan configuration parameters, pass in null for defaults</param> /// <param name="node">server node</param> /// <param name="ns">namespace - equivalent to database name</param> /// <param name="setName">optional set name - equivalent to database table</param> /// <param name="callback">read callback method - called with record data</param> /// <param name="binNames"> /// optional bin to retrieve. All bins will be returned if not specified. /// Aerospike 2 servers ignore this parameter. /// </param> /// <exception cref="AerospikeException">if transaction fails</exception> public void ScanNode(ScanPolicy policy, Node node, string ns, string setName, ScanCallback callback, params string[] binNames) { if (policy == null) { policy = scanPolicyDefault; } long taskId = Environment.TickCount; ScanCommand command = new ScanCommand(node, policy, ns, setName, callback, binNames, taskId); command.Execute(); }