Operaciones comunes

En esta página, se proporcionan ejemplos de algunas operaciones comunes que puedes realizar con la biblioteca de Common Android Reseller, incluidas las siguientes:

Crear objetos ResellerService

Usa las clases de fábrica de Samsung y Google para crear objetos ResellerService. Con los objetos ResellerService, hay un conjunto común de métodos disponibles para inscribir dispositivos 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 integrar 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 (no Samsung). Antes de hacerlo, debes seguir los pasos que se indican en Cómo comenzar a usar la inscripción sin intervención para obtener tu 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 de otras marcas requiere dos IDs de cliente.

Dispositivos Samsung

Para administrar dispositivos Samsung, 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 con un SamsungResellerService creado desde 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 realiza correctamente, la solicitud muestra un objeto CreateCustomerResponse del cual puedes extraer el ID de cliente de Knox.

Otros dispositivos Android

Para otros dispositivos Android, el cliente requiere un ID de cliente de inscripción automática. Si un cliente ya usa la inscripción sin contacto con otro distribuidor, usa su ID de cliente existente. De lo contrario, debes crear un objeto Customer. Para ello, llama a createCustomer con un ResellerService creado desde 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 realiza correctamente, la solicitud muestra un objeto CreateCustomerResponse. Puedes recuperar el ID del cliente de la respuesta.

Cómo reclamar un lote de dispositivos

Cuando reclamas un dispositivo, se crea una asociación entre el dispositivo y un cliente. Por ejemplo, si vendes un lote de dispositivos a un cliente, reclamarías 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

Con una tabla de IMEI, fabricantes e IDs 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 pedidos de dispositivos Android (que no son de Samsung). Luego, para cada lista, agrupa 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
Empresa XYZ 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 para los clientes, llama al ClaimDevicesAsync. Este ejemplo requiere dos solicitudes independientes: 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, completa con errores o fallida). 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);

Cómo dejar de reclamar un lote de dispositivos

Si anulas el reclamo de un dispositivo, se desvinculará del cliente. Es posible que necesites anular el reclamo de un dispositivo si se cancela un pedido o si no se puede completar correctamente un envío de dispositivos. Para dejar de reclamar 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: Cancela la vinculación de los dispositivos

Para dejar de reclamar dispositivos, llama a UnclaimDevicesAsync. En este ejemplo, se requieren dos solicitudes diferentes: una del objeto ResellerService de Samsung y otra del 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);

Cómo cambiar un dispositivo Samsung

Si un dispositivo debe reemplazarse por algún motivo, puedes cambiarlo. En este ejemplo, se asume que quieres cambiar un dispositivo Samsung por otro.

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 a 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, completa con errores o fallida). 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 a 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, 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);

Cómo cambiar un dispositivo Android (no Samsung)

Si un dispositivo debe reemplazarse por algún motivo, puedes cambiarlo. En este ejemplo, se asume que intercambias un dispositivo Android (que no es Samsung) por otro Android (que no es 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 a 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 a ClaimDevice

ClaimDeviceResponse response = googleResellerService.claimDevice(claimGoogleDeviceRequest);

Si se realiza correctamente, 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.