Operaciones comunes

En esta página, se proporcionan ejemplos de algunas operaciones comunes que puedes realizar con la Biblioteca común de revendedores de Android, que incluye

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 disponible para la inscripción Samsung y otros dispositivos Android

Dispositivos Samsung

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

Antes de hacerlo, debes integrar con 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 el comando Clase GoogleResellerServiceFactory para administrar otros dispositivos Android (que no sean de Samsung) dispositivos. Antes de hacerlo, deberás seguir los pasos que se indican en Cómo comenzar para la inscripción automática 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 que no es Samsung necesita dos IDs de cliente.

Dispositivos Samsung

Para administrar dispositivos Samsung, utiliza el ID de cliente de Knox del cliente. Para obtener la ID de cliente de Knox, primero debes crear un objeto Customer. Para ello, sigue estos pasos: llama a createCustomer con un SamsungResellerService creado a partir del 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

En el caso de otros dispositivos Android, el cliente requiere una inscripción automática. ID de cliente. Si un cliente ya usa la inscripción automática con otro revendedor, usarás su ID de cliente existente. De lo contrario, debes crear un Customer. Para ello, llama a createCustomer con un elemento 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 realiza correctamente, la solicitud muestra un objeto CreateCustomerResponse. Puedes recuperar el ID de cliente de la respuesta.

Cómo reclamar un lote de dispositivos

Cuando se reclama un dispositivo, se crea una asociación entre el dispositivo y un cliente. Para Por ejemplo, si vendes un lote de dispositivos a un cliente, puedes reclamar el 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 proveedores de de varios clientes.

Paso 1: Organiza los dispositivos y los clientes

Dada una tabla con los IMEI de los dispositivos, los fabricantes y los ID de los clientes dispositivos móviles, 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
Corporación ABC 11 Samsung

1234567801

1234567802

Otros dispositivos Android

Nombre del cliente ID de cliente Fabricante IMEI
Corporación ABC 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 a ClaimDevicesAsync. En este ejemplo, Requiere dos solicitudes diferentes: una del objeto ResellerService de Samsung y uno 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 falló). Para verificar el estado de una operación (por ejemplo, si la respuesta que se muestra 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 retirar un lote de dispositivos

Si anulas el reclamo de un dispositivo, se desvinculará del cliente. Quizás deben retirar el reclamo de un dispositivo si se cancela un pedido de dispositivo o un envío de no se pueden completar correctamente. Para retirar 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: Reclama los dispositivos

Para anular el reclamo de dispositivos, llama a UnclaimDevicesAsync. En este ejemplo, se requieren dos solicitudes separadas: una del objeto ResellerService de Samsung y otra de 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, completa con errores, o con errores) Para comprobar el estado de una operación (por ejemplo, si la respuesta que se muestra 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 necesitas reemplazar un dispositivo por algún motivo, puedes cambiarlo. Esta En el ejemplo anterior, se supone que cambiarás un dispositivo Samsung por otro Samsung. dispositivo.

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, completada, completa con errores, o falló). Para verificar el estado de una operación (por ejemplo, si la respuesta que se muestra 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, completada, completa con errores, o falló). Para verificar el estado de una operación (por ejemplo, si la respuesta que se muestra IN_PROGRESS), llama a getOperation:

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

Cómo intercambiar un dispositivo Android (que no sea de Samsung)

Si necesitas reemplazar un dispositivo por algún motivo, puedes cambiarlo. Esta ejemplo supone que quieres intercambiar un dispositivo Android (que no es de Samsung) por otro dispositivo Android (que no es de 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 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.