Opérations courantes

Cette page présente des exemples d'opérations courantes que vous pouvez effectuer avec la bibliothèque Common Android Reseller Library, 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 enregistrer des appareils Samsung et d'autres appareils Android.

Appareils Samsung

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

Pour cela, vous devez au préalable vous intégrer au 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 classe GoogleResellerServiceFactory pour gérer d'autres appareils Android (non Samsung). Pour ce faire, vous devez suivre la procédure décrite dans la section Premiers pas avec l'enregistrement sans contact afin d'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 appareils a besoin de deux ID client.

Appareils Samsung

Pour gérer les appareils Samsung, vous devez utiliser l'ID client Knox du client. Pour obtenir le numéro client Knox, vous devez d'abord créer un objet Customer. Pour ce faire, appelez 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 l'ID client Knox.

Autres appareils Android

Pour les autres appareils Android, le client a besoin d'un numéro client pour l'enregistrement sans contact. Si un client utilise déjà l'enregistrement sans contact avec un autre revendeur, utilisez son ID client existant. Sinon, vous devez créer un objet 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 la requête aboutit, elle renvoie un objet CreateCustomerResponse. Vous pouvez récupérer le numéro client à partir de la réponse.

Revendiquer un lot d'appareils

La revendication d'un appareil crée une association entre l'appareil et un client. Par exemple, si vous vendez un lot d'appareils à un client, vous devez revendiquer les appareils de ce client.

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

Étape 1: Organisez les appareils et les clients

À partir d'un tableau contenant les codes IMEI, les fabricants et les identifiants des clients auxquels les appareils ont été vendus, vous pouvez gérer les commandes en deux listes: les commandes d'appareils Samsung et les 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 IMEI
ABC Corp 11 Samsung

1234567801

1234567802

Autres appareils Android

Nom du client Numéro client Fabricant 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: Réclamez les appareils pour les clients

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

// 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 l'état de la requête (en cours, terminée, terminée avec des erreurs ou échouée). Pour vérifier l'état d'une opération (par exemple, si la réponse a 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);

Réclâmer un lot d'appareils

Si vous annulez la revendication d'un appareil, il est dissocié d'un client. Vous devrez peut-être annuler la revendication d'un appareil si une commande d'appareil est annulée ou si l'expédition d'appareils ne peut pas être effectuée. Pour annuler la revendication d'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 deux requêtes distinctes: l'une provenant de l'objet ResellerService Samsung 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 l'état de la requête (en cours, terminée, terminée avec des erreurs ou échouée). Pour vérifier l'état d'une opération (par exemple, si la réponse a 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. Dans cet exemple, nous partons du principe que vous échangez un appareil Samsung contre un autre appareil Samsung.

É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: Appeler UnclaimDeviceAsync

UnclaimDevicesResponse samsungResponse = samsungResellerService.unclaimDevicesAsync(unclaimSamsungDevicesRequest);

Une requête UnclaimDevicesAsync renvoie une liste d'objets Operation, qui contient l'état de la requête (en cours, terminée, terminée avec des erreurs ou échouée). Pour vérifier l'état d'une opération (par exemple, si la réponse a 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: Appeler ClaimDeviceAsync

ClaimDevicesResponse samsungResponse = samsungResellerService.claimDevicesAsync(claimSamsungDevicesRequest);

Une requête ClaimDevicesAsync renvoie une liste d'objets Operation, qui contient l'état de la requête (en cours, terminée, terminée avec des erreurs ou échouée). Pour vérifier l'état d'une opération (par exemple, si la réponse a 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. Cet exemple suppose 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: Appeler 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: Appeler ClaimDevice

ClaimDeviceResponse response = googleResellerService.claimDevice(claimGoogleDeviceRequest);

Si l'appel aboutit, il renvoie un objet ClaimDeviceResponse contenant le deviceId. Sinon, une exception courante contenant un code d'erreur est générée.