Operaciones comunes

En esta página, se proporcionan ejemplos de algunas operaciones comunes que puedes realizar con la biblioteca para distribuidores comunes de Android, como las siguientes:

Crear objetos ResellerService

Usa las clases de fábrica Samsung y Google para crear objetos ResellerService. Con los objetos ResellerService, hay un conjunto común de métodos disponible para inscribir Samsung y otros dispositivos Android.

Dispositivos Samsung

En el siguiente ejemplo, se muestra cómo crear un objeto ResellerService con la clase SamsungResellerServiceFactory para administrar dispositivos Samsung.

Antes de hacerlo, debes incorporar el Programa de implementación de Knox (KDP).

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

Otros dispositivos Android

En el siguiente ejemplo, se muestra cómo crear un objeto ResellerService con la clase GoogleResellerServiceFactory para administrar otros dispositivos Android (distintos de Samsung). Antes de hacerlo, debes seguir los pasos que se indican en Cómo comenzar a usar la inscripción automática para obtener la resellerId y la clave de la cuenta de servicio.

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

Crear objetos Customer

Un cliente que compra dispositivos Samsung y no Samsung requiere dos ID de cliente.

Dispositivos Samsung

Para administrar los dispositivos Samsung, se usa el ID de cliente de Knox del cliente. Para obtener el ID de cliente de Knox, primero debes crear un objeto Customer. Para ello, llama a createCustomer mediante un SamsungResellerService creado a partir de SamsungResellerServiceFactory. Por ejemplo:

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 se ejecuta de forma correcta, la solicitud muestra un objeto CreateCustomerResponse desde el que puedes extraer el ID de cliente de Knox.

Otros dispositivos Android

Para otros dispositivos Android, el cliente necesita un ID de cliente de inscripción automática. Si un cliente ya usa la inscripción automática con otro distribuidor, debes usar su ID de cliente existente. De lo contrario, debes crear un objeto Customer. Para ello, llama a createCustomer mediante un ResellerService creado a partir de GoogleResellerServiceFactory. Veamos un ejemplo:

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 se ejecuta de forma correcta, la solicitud muestra un objeto CreateCustomerResponse. Puedes recuperar el ID de cliente de la respuesta.

Reclamar un lote de dispositivos

Reclamar un dispositivo crea una asociación entre el dispositivo y un cliente. Por ejemplo, si vendes un lote de dispositivos a un cliente, debes reclamar los dispositivos para ese cliente.

En este ejemplo, se muestra una forma de procesar un lote de dispositivos que incluye pedidos de dispositivos de varios fabricantes (Samsung y otros dispositivos Android) de varios clientes.

Paso 1: Organiza los dispositivos y los clientes

Dada una tabla de IMEI, fabricantes y los ID de los clientes a los que se vendieron los dispositivos, una forma de administrar los pedidos es organizarlos en dos listas: pedidos de dispositivos Samsung y otros dispositivos Android (no Samsung). Luego, para cada lista, agrupe los dispositivos por cliente. Por ejemplo:

Dispositivos Samsung

Nombre del cliente ID de cliente de Samsung Knox Fabricante IMEI
ABC corp. 11 Samsung

1234567801

1234567802

Otros dispositivos Android

Nombre del cliente ID de cliente Fabricante IMEI
ABC corp. 21 Google 1234567803
XYZ corp. 22 Sony

1234567804

1234567805

Paso 2: Crea el objeto ClaimDevicesRequest

Dispositivos 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();

Otros dispositivos 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();

Paso 3: Reclama dispositivos para los clientes

Para reclamar dispositivos de clientes, llama a ClaimDevicesAsync. En este ejemplo, se requieren dos solicitudes diferentes: una del objeto ResellerService de Samsung y otra del objeto ResellerService de Google.

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

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

Una solicitud ClaimDevicesAsync muestra una lista de objetos Operation, que contienen el estado de la solicitud (en curso, completa, con errores o con errores). Para verificar el estado de una operación (por ejemplo, si la respuesta mostró IN_PROGRESS), llama a 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);

Retirar un lote de dispositivos

La anulación de un dispositivo se desvincula de un cliente. Es posible que debas anular la reclamación de un dispositivo si se cancela un pedido de dispositivo o no se puede completar un envío de dispositivos. Para quitar un lote de dispositivos, sigue estos pasos:

Paso 1: Crea el objeto UnclaimDevicesRequest

Dispositivos 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();

Otros dispositivos 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();

Paso 2: Retirar dispositivos

Para anular la reclamación de dispositivos, llama a UnclaimDevicesAsync. En este ejemplo, se requieren dos solicitudes separadas: una desde el objeto ResellerService de Samsung y otra desde el objeto ResellerService de Google.

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

Una solicitud UnclaimDevicesAsync muestra una lista de objetos Operation, que contienen el estado de la solicitud (en curso, completa, con errores o con errores). Para verificar el estado de una operación (por ejemplo, si la respuesta mostró IN_PROGRESS), llama a getOperation.

Dispositivos Samsung

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

Otros dispositivos Android

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

Intercambiar un dispositivo Samsung

Si es necesario reemplazar un dispositivo por algún motivo, puedes cambiarlo. En este ejemplo, se da por sentado que intercambias un dispositivo Samsung por otro dispositivo Samsung.

Paso 1: Crea un objeto 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();

Paso 2: Llama al número UnclaimDeviceAsync

UnclaimDevicesResponse samsungResponse = samsungResellerService.unclaimDevicesAsync(unclaimSamsungDevicesRequest);

Una solicitud UnclaimDevicesAsync muestra una lista de objetos Operation, que contiene el estado de la solicitud (en curso, completa, con errores o con errores). Para verificar el estado de una operación (por ejemplo, si la respuesta mostró IN_PROGRESS), llama a getOperation:

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

Paso 3: Crea un objeto 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();

Paso 4: Llama al ClaimDeviceAsync

ClaimDevicesResponse samsungResponse = samsungResellerService.claimDevicesAsync(claimSamsungDevicesRequest);

Una solicitud ClaimDevicesAsync muestra una lista de objetos Operation, que contiene el estado de la solicitud (en curso, completa, con errores o con errores). Para verificar el estado de una operación (por ejemplo, si la respuesta mostró IN_PROGRESS), llama a getOperation:

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

Intercambiar un dispositivo Android (no Samsung)

Si es necesario reemplazar un dispositivo por algún motivo, puedes cambiarlo. En este ejemplo, se da por sentado que intercambias un dispositivo Android (no Samsung) por otro dispositivo Android (no Samsung).

Paso 1: Crea un objeto UnclaimDeviceRequest

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

Paso 2: Llama al número UnclaimDevice

googleResponse = googleResellerService.unclaimDevice(unclaimGoogleDeviceRequest);

Paso 3: Crea un objeto 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();

Paso 4: Llama al ClaimDevice

ClaimDeviceResponse response = googleResellerService.claimDevice(claimGoogleDeviceRequest);

Si se ejecuta de forma correcta, la llamada muestra un objeto ClaimDeviceResponse que contiene el deviceId. De lo contrario, arroja una excepción común que contiene un código de error.