Häufige Vorgänge

Auf dieser Seite finden Sie Beispiele für gängige Vorgänge, die Sie mit der Common Android Reseller Library ausführen können, darunter:

ResellerService-Objekte erstellen

Verwenden Sie die Samsung- und Google-Standardklassen, um ResellerService-Objekte zu erstellen. Für ResellerService-Objekte gibt es eine Reihe gemeinsamer Methoden, mit denen Samsung- und andere Android-Geräte registriert werden können.

Samsung-Geräte

Das folgende Beispiel zeigt, wie Sie mithilfe der Klasse SamsungResellerServiceFactory ein ResellerService-Objekt erstellen, um Samsung-Geräte zu verwalten.

Dazu müssen Sie sich für das Knox Deployment Program (KDP) registrieren.

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

Andere Android-Geräte

Im folgenden Beispiel wird gezeigt, wie du mit der Klasse GoogleResellerServiceFactory ein ResellerService-Objekt erstellst, um andere Android-Geräte (nicht von Samsung) zu verwalten. Bevor Sie dies tun können, müssen Sie die Schritte unter Einführung in die Zero-Touch-Registrierung ausführen, um Ihre resellerId und den Dienstkontoschlüssel zu erhalten.

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

Customer-Objekte erstellen

Für Kunden, die Samsung- und andere Geräte von Samsung kaufen, sind zwei Kundennummern erforderlich.

Samsung-Geräte

Zum Verwalten von Samsung-Geräten verwenden Sie die Knox-Kundennummer des Kunden. Um die Knox-Kunden-ID abzurufen, müssen Sie zuerst ein Customer-Objekt erstellen. Rufen Sie dazu createCustomer mit einem SamsungResellerService auf, das aus SamsungResellerServiceFactory erstellt wurde. Beispiel:

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

Bei Erfolg gibt die Anfrage ein CreateCustomerResponse-Objekt zurück, aus dem Sie die Knox-Kundennummer extrahieren können.

Andere Android-Geräte

Für andere Android-Geräte benötigt der Kunde eine Kunden-ID für die Zero-Touch-Registrierung. Wenn ein Kunde bereits die Zero-Touch-Registrierung bei einem anderen Reseller verwendet, verwenden Sie dessen vorhandene Kundennummer. Andernfalls müssen Sie ein Customer-Objekt erstellen. Dazu rufen Sie createCustomer mit einer aus GoogleResellerServiceFactory erstellten ResellerService auf. Hier ein Beispiel:

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

Wenn der Vorgang erfolgreich ist, wird ein CreateCustomerResponse-Objekt zurückgegeben. Sie können die Kundennummer aus der Antwort abrufen.

Mehrere Geräte beanspruchen

Durch das Beanspruchen eines Geräts wird eine Verknüpfung zwischen dem Gerät und einem Kunden erstellt. Wenn Sie beispielsweise eine Reihe von Geräten an einen Kunden verkaufen, müssen Sie die Geräte für diesen Kunden beanspruchen.

In diesem Beispiel wird eine Möglichkeit zur Verarbeitung eines Geräte-Batches gezeigt, der Bestellungen von Geräten verschiedener Hersteller (Samsung und andere Android-Geräte) von mehreren Kunden enthält.

Schritt 1: Geräte und Kunden organisieren

Wenn Sie eine Tabelle mit den IMEIs der Geräte, den Herstellern und den IDs der Kunden haben, an die die Geräte verkauft wurden, können Sie die Bestellungen in zwei Listen unterteilen: Bestellungen für Samsung-Geräte und Bestellungen für andere Android-Geräte (nicht Samsung). Gruppieren Sie dann für jede Liste die Geräte nach Kunden. Beispiel:

Samsung-Geräte

Kundenname Samsung Knox-Kundennummer Hersteller IMEI
ABC Corp 11 Samsung

1234567801

1234567802

Andere Android-Geräte

Kundenname Kundennummer Hersteller IMEI
Logo: ABC Corporation 21 Google 1234567803
XYZ-Unternehmen 22 Sony

1234567804

1234567805

Schritt 2: ClaimDevicesRequest-Objekt erstellen

Samsung-Geräte

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

Andere Android-Geräte

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

Schritt 3: Geräte für Kunden beanspruchen

Wenn Sie Geräte für Kunden beanspruchen möchten, rufen Sie ClaimDevicesAsync an. Für dieses Beispiel sind zwei separate Anfragen erforderlich: eine vom Samsung-ResellerService-Objekt und eine vom Google-ResellerService-Objekt.

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

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

Eine ClaimDevicesAsync-Anfrage gibt eine Liste von Operation-Objekten zurück, die den Status der Anfrage enthalten (in Bearbeitung, abgeschlossen, mit Fehlern oder fehlgeschlagen). Wenn du den Status eines Vorgangs prüfen möchtest (z. B. ob die Antwort IN_PROGRESS zurückgegeben wurde), ruf getOperation auf.

// 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);

Anspruch auf mehrere Geräte aufheben

Wenn du die Inhaberschaft für ein Gerät zurückziehst, wird die Verknüpfung mit einem Kunden aufgehoben. Möglicherweise müssen Sie den Anspruch auf ein Gerät zurückziehen, wenn eine Gerätebestellung storniert wird oder ein Geräteversand nicht erfolgreich abgeschlossen werden kann. So widerrufen Sie den Anspruch auf eine Gruppe von Geräten:

Schritt 1: UnclaimDevicesRequest-Objekt erstellen

Samsung-Geräte

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

Andere Android-Geräte

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

Schritt 2: Anspruch auf Geräte aufheben

Wenn Sie die Anspruchnahme von Geräten aufheben möchten, rufen Sie UnclaimDevicesAsync an. Für dieses Beispiel sind zwei separate Anfragen erforderlich: eine vom Samsung-ResellerService-Objekt und eine vom Google-ResellerService-Objekt.

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

Eine UnclaimDevicesAsync-Anfrage gibt eine Liste von Operation-Objekten zurück, die den Status der Anfrage enthalten (in Bearbeitung, abgeschlossen, abgeschlossen mit Fehlern oder fehlgeschlagen). Wenn Sie den Status eines Vorgangs prüfen möchten (z. B. wenn die Antwort IN_PROGRESS zurückgegeben hat), rufen Sie getOperation auf.

Samsung-Geräte

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

Andere Android-Geräte

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

Samsung-Gerät umtauschen

Wenn ein Gerät aus irgendeinem Grund ersetzt werden muss, können Sie es umtauschen. In diesem Beispiel wird davon ausgegangen, dass Sie ein Samsung-Gerät gegen ein anderes Samsung-Gerät eintauschen.

Schritt 1: UnclaimDeviceRequest-Objekt erstellen

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

Schritt 2: UnclaimDeviceAsync anrufen

UnclaimDevicesResponse samsungResponse = samsungResellerService.unclaimDevicesAsync(unclaimSamsungDevicesRequest);

Eine UnclaimDevicesAsync-Anfrage gibt eine Liste von Operation-Objekten zurück, die den Status der Anfrage enthält (in Bearbeitung, abgeschlossen, abgeschlossen mit Fehlern oder fehlgeschlagen). Wenn du den Status eines Vorgangs prüfen möchtest (z. B. ob die Antwort IN_PROGRESS zurückgegeben wurde), ruf getOperation auf:

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

Schritt 3: ClaimDeviceRequest-Objekt erstellen

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

Schritt 4: ClaimDeviceAsync anrufen

ClaimDevicesResponse samsungResponse = samsungResellerService.claimDevicesAsync(claimSamsungDevicesRequest);

Eine ClaimDevicesAsync-Anfrage gibt eine Liste von Operation-Objekten zurück, die den Status der Anfrage enthält (in Bearbeitung, abgeschlossen, abgeschlossen mit Fehlern oder fehlgeschlagen). Wenn du den Status eines Vorgangs prüfen möchtest (z. B. ob die Antwort IN_PROGRESS zurückgegeben wurde), ruf getOperation auf:

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

Android-Gerät (kein Samsung) umtauschen

Wenn ein Gerät aus irgendeinem Grund ersetzt werden muss, können Sie es umtauschen. In diesem Beispiel wird davon ausgegangen, dass Sie ein Android-Gerät (kein Samsung-Gerät) gegen ein anderes Android-Gerät (kein Samsung-Gerät) eintauschen.

Schritt 1: UnclaimDeviceRequest-Objekt erstellen

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

Schritt 2: UnclaimDevice anrufen

googleResponse = googleResellerService.unclaimDevice(unclaimGoogleDeviceRequest);

Schritt 3: ClaimDeviceRequest-Objekt erstellen

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

Schritt 4: ClaimDevice anrufen

ClaimDeviceResponse response = googleResellerService.claimDevice(claimGoogleDeviceRequest);

Bei Erfolg gibt der Aufruf ein ClaimDeviceResponse-Objekt mit der deviceId zurück. Andernfalls wird eine allgemeine Ausnahme mit einem Fehlercode geworfen.