Opérations courantes

Cette page fournit des exemples d'opérations courantes que vous pouvez effectuer avec la bibliothèque Common Android Reseller, y compris:

Créer des objets ResellerService

Utilisez les classes de fabrique Samsung et Google pour créer des objets ResellerService. Avec les objets ResellerService, un ensemble commun de méthodes est disponible pour l'enregistrement Samsung et autres appareils Android.

Appareils Samsung

L'exemple ci-dessous montre comment créer un objet ResellerService à l'aide de la méthode SamsungResellerServiceFactory pour gérer les appareils Samsung.

Pour cela, vous devez au préalable intégrer dans le cadre du programme de déploiement Knox (KDP).

ResellerService samsungResellerService = SamsungResellerServiceFactory.createResellerService(resellerId, serviceAccountKeyFilePath, clientIdentifier);

Autres appareils Android

L'exemple ci-dessous montre comment créer un objet ResellerService à l'aide de la méthode Classe GoogleResellerServiceFactory permettant de gérer d'autres appareils Android (autres que Samsung) appareils. Avant cela, vous devez suivre la procédure décrite dans la section Premiers pas pour l'enregistrement sans contact pour obtenir votre resellerId et votre clé de compte de service.

ResellerService googleResellerService = GoogleResellerServiceFactory.createResellerService(resellerId, serviceAccountKeyFilePath);

Créer des objets Customer

Un client qui achète des appareils Samsung et d'autres que Samsung a besoin de deux numéros client.

Appareils Samsung

Pour gérer les appareils Samsung, vous devez utiliser le numéro client Knox du client. Pour obtenir numéro client Knox, vous devez d'abord créer un objet Customer. Pour ce faire, appeler createCustomer à l'aide d'un SamsungResellerService créé à partir de SamsungResellerServiceFactory Exemple :

CreateCustomerRequest request = CreateCustomerRequest.newBuilder()
    .setCustomerName("TestCustomer") .addPrimaryEmails("superAdmin@gmail.com")
    .putVendorParams("country", "US") .putVendorParams("firstName", "Avery")
    .putVendorParams("lastName", "Yamada") .putVendorParams("service", "KME")
    .build();
CreateCustomerResponse response = samsungResellerService.createCustomer(request);
String companyId = response.getCustomer().getCompanyReference().getCompanyId();

Si la requête aboutit, elle renvoie un objet CreateCustomerResponse à partir duquel vous pouvez extraire le numéro client Knox.

Autres appareils Android

Pour les autres appareils Android, le client exige un enregistrement sans contact. numéro client. Si un client utilise déjà l'enregistrement sans contact avec un autre revendeur, vous utilisez son numéro client existant. Sinon, vous devez créer Customer. Pour ce faire, appelez createCustomer à l'aide d'un ResellerService. créé à partir de GoogleResellerServiceFactory. Voici un exemple :

CreateCustomerRequest request = CreateCustomerRequest.newBuilder()
    .setCustomerName("TestCustomer")
    .addPrimaryEmails("owner@gmail.com")
    .addSecondaryEmails("admin@gmail.com")
    .build();
CreateCustomerResponse response = googleResellerService.createCustomer(request);
String companyId = response.getCustomer().getCompanyReference().getCompanyId();

Si l'opération réussit, la requête renvoie un objet CreateCustomerResponse. Vous pouvez récupérer le numéro client à partir de la réponse.

Revendiquer un lot d'appareils

Le fait de revendiquer un appareil crée une association entre l'appareil et le client. Pour Par exemple, si vous vendez un lot d'appareils à un client, vous devez demander appareils pour ce client.

Cet exemple présente une façon de traiter un lot de périphériques comprenant commandes d'appareils de plusieurs fabricants (Samsung et d'autres appareils) de plusieurs clients.

Étape 1: Organisez les appareils et les clients

À partir d'un tableau listant les codes IMEI des appareils, les fabricants et les identifiants des clients, d'appareils vendus. L'une des façons de gérer les commandes consiste à les organiser en listes: commandes d'appareils Samsung et autres commandes d'appareils Android (autres que Samsung). Ensuite, pour chaque liste, regroupez les appareils par client. Exemple :

Appareils Samsung

Nom du client Numéro client Samsung Knox Fabricant Code IMEI
Société ABC 11 Samsung

1234567801

1234567802

Autres appareils Android

Nom du client Numéro client Fabricant Code IMEI
Société ABC 21 Google 1234567803
Société XYZ 22 Sony

1234567804

1234567805

Étape 2: Créez un objet ClaimDevicesRequest

Appareils Samsung

// Note: You can only claim devices for a single customer in each request.
ClaimDevicesRequest claimSamsungDevicesRequest = ClaimDevicesRequest.newBuilder()
   .addClaims(
       DeviceClaim.newBuilder()
           .setCustomer(
               CompanyReference.newBuilder()
                   .setVendor(Vendor.SAMSUNG)
                   .setCompanyId("11")
                   .build())
           .setDeviceIdentifier(
               DeviceIdentifier.newBuilder()
                   .setImei("1234567801")
                   .setManufacturer("Samsung")
                   .build())
       .build())
   .addClaims(
       DeviceClaim.newBuilder()
           .setCustomer(
               CompanyReference.newBuilder()
                   .setVendor(Vendor.SAMSUNG)
                   .setCompanyId("11")
                   .build())
           .setDeviceIdentifier(
               DeviceIdentifier.newBuilder()
                   .setImei("1234567802")
                   .setManufacturer("Samsung")
                   .build())
           .build())
   .build();

Autres appareils Android

ClaimDevicesRequest claimGoogleDevicesRequest = ClaimDevicesRequest.newBuilder()
    .addClaims(
        DeviceClaim.newBuilder()
            .setCustomer(
                CompanyReference.newBuilder()
                    .setVendor(Vendor.GOOGLE)
                    .setCompanyId("21")
                    .build())
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567803")
                    .setManufacturer("Google")
                    .build())
            .build())
    .addClaims(
        DeviceClaim.newBuilder()
            .setCustomer(
                CompanyReference.newBuilder()
                    .setVendor(Vendor.GOOGLE)
                    .setCompanyId("22")
                    .build())
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567804")
                    .setManufacturer("Sony")
                    .build())
            .build())
    .addClaims(
         DeviceClaim.newBuilder()
             .setCustomer(
                 CompanyReference.newBuilder()
                     .setVendor(Vendor.GOOGLE)
                     .setCompanyId("22")
                     .build())
             .setDeviceIdentifier(
                 DeviceIdentifier.newBuilder()
                     .setImei("1234567805")
                     .setManufacturer("Sony")
                     .build())
             .build())
    .build();

Étape 3: Revendiquer les appareils des clients

Pour revendiquer les appareils de vos clients, appelez le ClaimDevicesAsync. Cet exemple nécessite deux requêtes distinctes: l'une provenant de l'objet Samsung ResellerService et une autre à partir de l'objet Google ResellerService.

// Samsung devices
ClaimDevicesResponse samsungResponse = samsungResellerService.claimDevicesAsync(claimSamsungDevicesRequest);

// Other Android devices
ClaimDevicesResponse googleResponse = googleResellerService.claimDevicesAsync(claimGoogleDevicesRequest);

Une requête ClaimDevicesAsync renvoie une liste d'objets Operation, qui contiennent le statut de la demande (en cours, terminé, terminé avec des erreurs, ou en échec). Pour vérifier l'état d'une opération (par exemple, si la réponse renvoyé IN_PROGRESS), appelez getOperation.

// Samsung devices
GetOperationRequest samsungOperationRequest = GetOperationRequest.newBuilder().setOperationId(samsungOperationId).build();
Operation samsungOperation = samsungResellerService.getOperation(samsungOperationRequest);

// Other Android devices
GetOperationRequest googleOperationRequest = GetOperationRequest.newBuilder().setOperationId(googleOperationId).build();
Operation googleOperation = googleResellerService.getOperation(googleOperationRequest);

Retirer la revendication d'un lot d'appareils

Si vous annulez la revendication d'un appareil, celui-ci sera dissocié du client. Vous pourriez n'avez pas besoin de revendiquer un appareil si la commande d'un appareil est annulée ou si une livraison appareils n'a pas abouti. Pour retirer un lot d'appareils : procédez comme suit:

Étape 1: Créez un objet UnclaimDevicesRequest

Appareils Samsung

// Each request can only unclaim devices belonging to a single customer. The request must also
// include the customer's Samsung Knox customer ID.
UnclaimDevicesRequest unclaimSamsungDevicesRequest = UnclaimDevicesRequest.newBuilder()
    .putVendorParams("customerId", "11")
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567801")
                    .build())
        .build())
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567802")
                    .build())
            .build())
    .build();

Autres appareils Android

UnclaimDevicesRequest unclaimGoogleDevicesRequest = UnclaimDevicesRequest.newBuilder()
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567803")
                    .build())
            .build())
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567804")
                    .build())
            .build())
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567805")
                    .build())
            .build())
    .build();

Étape 2: Retirer la revendication des appareils

Pour annuler la revendication d'appareils, appelez UnclaimDevicesAsync. Cet exemple nécessite des requêtes distinctes, l'une provenant de l'objet Samsung ResellerService et l'autre provenant de l'objet Google ResellerService.

UnclaimDevicesResponse samsungResponse = samsungResellerService.unclaimDevicesAsync(unclaimSamsungDevicesRequest);
UnclaimDevicesResponse googleResponse = googleResellerService.unclaimDevicesAsync(unclaimGoogleDevicesRequest);

Une requête UnclaimDevicesAsync renvoie une liste d'objets Operation, qui contiennent le statut de la demande (en cours, terminé, terminé avec des erreurs, ou en échec) Pour vérifier l'état d'une opération (par exemple, si la réponse renvoyé IN_PROGRESS), appelez getOperation.

Appareils Samsung

GetOperationRequest samsungOperationRequest = GetOperationRequest.newBuilder().setOperationId(samsungOperationId).build();
Operation samsungOperation = samsungResellerService.getOperation(samsungOperationRequest);

Autres appareils Android

GetOperationRequest googleOperationRequest = GetOperationRequest.newBuilder().setOperationId(googleOperationId).build();
Operation googleOperation = googleResellerService.getOperation(googleOperationRequest);

Échanger un appareil Samsung

Si un appareil doit être remplacé pour une raison quelconque, vous pouvez l'échanger. Ce Par exemple, nous supposons que vous échangez un appareil Samsung contre un appareil Samsung appareil.

Étape 1: Créez un objet UnclaimDeviceRequest

// Note: The request must include the customer's Samsung Knox customer ID.
UnclaimDevicesRequest unclaimSamsungDevicesRequest = UnclaimDevicesRequest.newBuilder()
    .putVendorParams("customerId", "11")
    .addUnclaims(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567801")
                    .build())
        .build())
    .build();

Étape 2: Appelez UnclaimDeviceAsync

UnclaimDevicesResponse samsungResponse = samsungResellerService.unclaimDevicesAsync(unclaimSamsungDevicesRequest);

Une requête UnclaimDevicesAsync renvoie une liste d'objets Operation, qui contient l'état de la demande (en cours, terminé, terminé avec des erreurs, ou en échec). Pour vérifier l'état d'une opération (par exemple, si la réponse renvoyé IN_PROGRESS), appelez getOperation:

GetOperationRequest samsungOperationRequest = GetOperationRequest.newBuilder().setOperationId(samsungOperationId).build();
Operation samsungOperation = samsungResellerService.getOperation(samsungOperationRequest);

Étape 3: Créez un objet ClaimDeviceRequest

ClaimDevicesRequest claimSamsungDevicesRequest = ClaimDevicesRequest.newBuilder()
   .addClaims(
       DeviceClaim.newBuilder()
           .setCustomer(
               CompanyReference.newBuilder()
                   .setVendor(Vendor.SAMSUNG)
                   .setCompanyId("11")
                   .build())
           .setDeviceIdentifier(
               DeviceIdentifier.newBuilder()
                   .setImei("1234567806")
                   .setManufacturer("Samsung")
                   .build())
       .build())
   .build();

Étape 4: Appelez ClaimDeviceAsync

ClaimDevicesResponse samsungResponse = samsungResellerService.claimDevicesAsync(claimSamsungDevicesRequest);

Une requête ClaimDevicesAsync renvoie une liste d'objets Operation, qui contient l'état de la demande (en cours, terminé, terminé avec des erreurs, ou en échec). Pour vérifier l'état d'une opération (par exemple, si la réponse renvoyé IN_PROGRESS), appelez getOperation:

GetOperationRequest samsungOperationRequest = GetOperationRequest.newBuilder().setOperationId(samsungOperationId).build();
Operation samsungOperation = samsungResellerService.getOperation(samsungOperationRequest);

Échanger un appareil Android (autre que Samsung)

Si un appareil doit être remplacé pour une raison quelconque, vous pouvez l'échanger. Ce Par exemple, nous supposons que vous échangez un appareil Android (autre que Samsung) contre un autre appareil Android (autre que Samsung).

Étape 1: Créez un objet UnclaimDeviceRequest

UnclaimDeviceRequest unclaimGoogleDeviceRequest = UnclaimDeviceRequest.newBuilder()
    .setUnclaim(
        DeviceUnclaim.newBuilder()
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567803")
                    .build())
            .build())
    .build();

Étape 2: Appelez UnclaimDevice

googleResponse = googleResellerService.unclaimDevice(unclaimGoogleDeviceRequest);

Étape 3: Créez un objet ClaimDeviceRequest

ClaimDeviceRequest claimGoogleDeviceRequest = ClaimDeviceRequest.newBuilder()
    .setClaim(
        DeviceClaim.newBuilder()
            .setCustomer(
                CompanyReference.newBuilder()
                    .setVendor(Vendor.GOOGLE)
                    .setCompanyId("21")
                    .build())
            .setDeviceIdentifier(
                DeviceIdentifier.newBuilder()
                    .setImei("1234567807")
                    .setManufacturer("Google")
                    .build())
            .build())
       .build();

Étape 4: Appelez ClaimDevice

ClaimDeviceResponse response = googleResellerService.claimDevice(claimGoogleDeviceRequest);

Si l'appel aboutit, l'appel renvoie un objet ClaimDeviceResponse contenant le deviceId Sinon, il génère une exception commune contenant un code d'erreur.