SDK BeaconScan

# Guide du kit de développement du logiciel MinewBeacon Scan

## Installation

### CocoaPods

MinewBeaconScan is available through [Cosses de cacao](http://cocoapods.org/). Pour l'installer, ajoutez simplement la ligne suivante à votre Podfile, puis importez <MinewBeaconScan>:

### Manuellement

1.  Téléchargez le projet et déposez le dossier MinewBeaconScan.framework dans votre projet.
2.  Importer le fichier `<MinewBeaconScan>`.

```c
#import <MinewBeaconScan>
```

## Requirements

This library requires iOS 9.0+.

## Configs before development

The SDK used CoreLocation and CoreBluetooth.

Afin de se conformer aux spécifications d'audit d'Apple, nous devons faire une distinction entre l'utilisation ou non d'une tâche en arrière-plan.

pour le développeur, aucune tâche en arrière-plan n'est requise:

```c
  // 1. définir backgroundSupport sur NON 
    [aManager startScan:arrière-plan uuidsSupport: NON];

// 2. désactivez la mise à jour de l'emplacement et utilise les accessoires Bluetooth LE dans votre projet.

//  PS: En raison des restrictions iOS, si certains appareils ne prennent pas en charge l'analyse en arrière-plan, vous n'obtiendrez pas ces données pour l'appareil lorsque l'application entrera en arrière-plan, bien que le processus de candidature ne soit pas suspendu.
```

for the developer require background task：

```c
  // 1. définir backgroundSupport sur OUI
  [aManager startScan:arrière-plan uuidsSupport :OUI];
   
  // 2、activer la mise à jour de l'emplacement et utiliser les accessoires Bluetooth LE en même temps, tu dois ajouter "NSLocationAlwaysUsageDescription" élément dans le fichier info.plist de votre projet.

// PS：Le SDK passera en mode arrière-plan et continuera à analyser,s'il existe des appareils prenant en charge le mode arrière-plan, toutes les méthodes déléguées seront exécutées normalement.
```

Configs for "info.plist"

```c
   
<key>NSBluetoothPeripheralUsageDescription</key> 
<string>L'application utilisera Bluetooth pour communiquer avec les appareils.</string> 
   
<key>NSLocationUsageDescription</key> 
<string>L'application enregistrera votre position</string> 
 
<key>NSLocationWhenInUseUsageDescription</key> 
<string>L'application enregistrera votre position</string> 
  

 
<key>NSLocationAlwaysUsageDescription</key> 
<string>L'application enregistrera votre position</string> 
```

## Get Started

MinewBeaconManager (en tant que gestionnaire ci-dessous) peut analyser ou arrêter l'analyse des appareils à proximité, cela créera **Minewbeacon**(comme balise ci-dessous) instance pour chaque appareil. il écoutera la mise à jour des données et apparaîtra(nous pensons qu'un appareil a disparu s'il ne met pas à jour les données en quelques secondes, nous pensons qu'un appareil est apparu s'il est analysé pour la première fois ou analysé à partir de "disparaître" ) état des appareils, en même temps, Le gestionnaire écoutera les changements d'état Bluetooth du téléphone portable. Voici le code ci-dessous:

1.  Obtenir l'instance partagée du gestionnaire, définir un délégué:

```c
MinewBeaconManager *manager = [MinewBeaconManager sharedInstance];
manager.delegate = soi;
```

2.  Lancer la recherche d'appareils.

```c
[gestionnaire startScan:@[@"uuid1", @"uuid2",...] arrière-planSupport:NON];
```

3.  obtenir les données des appareils à partir de la méthode déléguée.

```c
// si le gestionnaire a trouvé des appareils, cette méthode sera exécutée toutes les secondes, 
- (vide)minewBeaconManager:(MinewBeaconManager *)gestionnaire didRangeBeacons:(NSArray<MinewBeacon *> *)balises
{
    NSLog(@"balises actuelles:%@", balises);
}
```

4.  obtenir les données de l'instance de balise.
    
    Par méthode "-(MinewBeaconValue \*)obtenirBeaconValue:(BeaconValueIndex)indice". pour la polyvalence des données, nous utilisons **MinewBeaconValue** pour gérer tous les types de données, L'instance BeaconValue peut être une chaîne, int, float ou booléen, chaque "indice" correspond à une valeur, comme le code ci-dessous:

```c
MinewBeacon *beacon = beacons[0];

// uuid
NSString *uuid = [balise getBeaconValue:BeaconValueIndex_UUID].valeur de chaîne; 
// major
NSInteger major = (long)[balise getBeaconValue:BeaconValueIndex_Major].valeurint;
// minor
NSInteger minor = (long)[balise getBeaconValue:BeaconValueIndex_Minor].valeurint;
```

Table for ValueIndex and data types

| indice | Nom des données | Taper | Détail |
| --- | --- | --- | --- |
| BeaconValueIndex_UUID | uuide | valeur de chaîne |  |
| BeaconValueIndex_Nom | Nom | valeur de chaîne |  |
| BeaconValueIndex_Major | majeur | valeurint |  |
| BeaconValueIndex_Minor | mineure | valeurint |  |
| BeaconValueIndex_WechatId | identifiant wechat | valeurint | Appareil partiel |
| BeaconValueIndex_Mac | Adresse Mac | valeur de chaîne | Appareil partiel |
| BaliseValueIndex_RSSI | RSSI | valeurint |  |
| BeaconValueIndex_BatteryLevel | Batterie | valeurint |  |
| BeaconValueIndex_Temperature | Température | valeur flottante | Appareil partiel |
| BeaconValueIndex_Humidité | Humidité | valeur flottante |  |
| BeaconValueIndex_Txpower | txPuissance | valeurint |  |
| BeaconValueIndex_InRange | dans la gamme | valeur booléenne |  |
| BeaconValueIndex_Connectable | Connectable | valeur booléenne |  |

il vous suffit d'obtenir les données souhaitées via les index ci-dessus.

Maintenant, nous terminons l'utilisation de base du SDK, plus de codes ci-dessous:

écouter l'appareil apparaître et disparaître les modifications.

```c
// faire disparaître les appareils.
- (vide)minewBeaconManager:(MinewBeaconManager *)le gestionnaire disparaîtBalises:(NSArray<MinewBeacon *> *)balises
{
    NSLog(@"---disparaître les balises:%@", balises);
}

// apparaissent des appareils.
- (vide)minewBeaconManager:(MinewBeaconManager *)le gestionnaire apparaîtBeacons:(NSArray<MinewBeacon *> *)balises
{
    NSLog(@"apparaissent des balises:%@", balises);
}
```

Listen to the Bluetooth state of cellphone.

Trois états Bluetooth:

État Bluetooth：BluetoothStatePowerOn (mise sous tension)，BluetoothStatePowerOff (mise hors tension)，BluetoothStateUnknown（unknown）

```c
// écoutez les changements d'état Bluetooth
- (vide)minewBeaconManager:(MinewBeaconManager *)gestionnaire didUpdateState:(État Bluetooth)État
{
    NSLog(@"État Bluetooth:%ld", (long)État);
}
```

you can also check bluetooth state like this:

```c
BluetoothState state = [aManager checkBluetoothState];

si(état == BluetoothStatePowerOn)
  NSLog(@"Bluetooth est activé maintenant.");
sinon si ...
```

## Référence de classe

### MinewBeacon

Device instance Class,

```c
// obtenir les données de l'appareil
 -(MinewBeaconValue *)obtenirBeaconValue:(BeaconValueIndex)indice;

// comme obtenir l'UUID：
  [aBeacon obtientBeaconValue:BeaconValueIndex_UUID].valeur de chaîne;

// indice de "BeaconValueIndex"；
 // !!!:you should get data by its type
typedef NS_ENUM(NSEntier, BeaconValueIndex) {
     // UUID      
    BeaconValueIndex_UUID = 1,  // valeur de chaîne
    // Major 
    BeaconValueIndex_Major,   // valeurint
    // Minor
    BeaconValueIndex_Minor,   // valeurint
    // Name
    BeaconValueIndex_Name,   // valeur de chaîne
    // RSSI
    BeaconValueIndex_RSSI,   //  valeurint
    // battery
    BeaconValueIndex_BatteryLevel,  // valeurint
    // temperature
    BeaconValueIndex_Temperature, 
    // humidity
    BeaconValueIndex_Humidity, 
    // TxPower
    BeaconValueIndex_TxPower,  // valeurint
    // in scanning range or not
    BeaconValueIndex_InRage,  // valeur booléenne
    // identifiant wechat，（Partial device）
    BeaconValueIndex_WechatId, // valeurint
};
```

### MinewBeaconValue

Device value instance class

```c
// get int value
@property (non atomique, lecture seulement, attribuer) NSInteger valeur entière;

// get float value
@property (non atomique, lecture seulement, attribuer) float valeur flottante;

// get string value
@property (non atomique, lecture seulement, copie) NSString *stringValue;

// get data value
@property (non atomique, lecture seulement, fort) NSData *donnéesValeur;

// get bool value
@property (non atomique, lecture seulement, attribuer) BOOL valeur booléenne;
```

### MinewBeaconManager

Global Manager class.

```c
// delegate
@protocol MinewBeaconManagerDelegate <NSObject>
@facultatif

// nouveaux appareils analysés, rappel tous les 3 secondes, 
- (vide)minewBeaconManager:(MinewBeaconManager * )le gestionnaire apparaîtBeacons:(NSArray<MinewBeacon *> *)balises;

// écoutez les appareils qui disparaissent (ne met pas à jour les données dans 10 deuxième.)
- (vide)minewBeaconManager:(MinewBeaconManager * )le gestionnaire disparaîtBalises:(NSArray<MinewBeacon *> *)balises;

// écoutez les appareils qui apparaissent (scanné pour la première fois.)
- (vide)minewBeaconManager:(MinewBeaconManager * )gestionnaire didRangeBeacons:(NSArray<MinewBeacon *> * )balises;

@fin

// 
@interface MinewBeaconManager : NSObjet

// instance partagée
- (MinewBeaconManager  *)Instance partagée;

// démarrer l'analyse des appareils, "uuides" est un tableau de chaînes uuid, "activer" est un commutateur pour la prise en charge de l'analyse en arrière-plan 
- (vide)démarrerScan:(NSArray<NSString *> *)arrière-plan uuidsSupport :(BOOL)activer;

// arrêter la recherche d'appareil.
- (vide)Arrêter l'analyse;

// delegate
@property (non atomique, fort) identifiant <MinewBeaconManagerDelegate> déléguer;

@propriété (non atomique, lecture seulement, attribuer) État Bluetooth

// tous les appareils analysés.
@propriété (non atomique, lecture seulement, copie) NSArray<MinewBeacon *> *balises scannées;

// tous les appareils à portée.
@propriété (non atomique, lecture seulement, copie) NSArray<MinewBeacon *> *inRangeBeacons;

@end

```

## Journal des modifications

-   2017.10.16 version anglaise
-   2016.12.22 mise à jour pour iOS 10
-   2016.11.29 mise à jour pour le nouveau firmware.
-   2016.9.18 mise à jour pour l'examen d'Apple
-   2020.09.18 mise à jour pour le périphérique scan v3。

Dernière mise à jour:: 12/22/2020, 9:49:53 SUIS