Android SDK

import co.onecheck.ones1ght.android.*           // OneS1ght · FloorSession · SdkError · 리스너
import co.onecheck.ones1ght.android.model.*     // Building · Floor · Zone · Coordinates · Trigger · ConfigChange
import co.onecheck.ones1ght.android.network.ApiError
import co.onecheck.ones1ght.android.runtime.LogLevel

import co.onecheck.ones1ght.android.*;          // OneS1ght · FloorSession · SdkError · Callback · 리스너
import co.onecheck.ones1ght.android.model.*;    // Building · Floor · Zone · Coordinates · Trigger · ConfigChange
import co.onecheck.ones1ght.android.network.ApiError;
import co.onecheck.ones1ght.android.runtime.LogLevel;

OneS1ght.initialize(context = context.applicationContext, sdkKey = "YOUR_SDK_KEY")

OneS1ght.initialize(context, "YOUR_SDK_KEY", new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

val status = OneS1ght.requestPermission(activity)

OneS1ght.requestPermission(activity, new Callback<PermissionStatus>() {
    @Override public void onSuccess(PermissionStatus status) { }
    @Override public void onError(Throwable error) { }
});

OneS1ght.setLanguage("ko")

OneS1ght.setLanguage("ko");

OneS1ght.onDebugLog = DebugLogListener { level, message ->
    if (level >= LogLevel.WARN) Log.w("OneS1ght", message)
}

OneS1ght.setOnDebugLog((level, message) -> {
    if (level.compareTo(LogLevel.WARN) >= 0) Log.w("OneS1ght", message);
});

OneS1ght.reset()

OneS1ght.reset(new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

val ready = OneS1ght.isInitialized

boolean ready = OneS1ght.isInitialized();

when (OneS1ght.deviceAvailability) {   // initialize() 뒤에
    DeviceAvailability.AVAILABLE            -> Unit
    DeviceAvailability.OS_VERSION_TOO_LOW   -> Unit
    DeviceAvailability.DEVICE_NOT_SUPPORTED -> Unit
    else                                    -> Unit
}

DeviceAvailability availability = OneS1ght.getDeviceAvailability();
boolean available = OneS1ght.isDeviceAvailable();

val mapKey = OneS1ght.googleMapKey   // String?

String mapKey = OneS1ght.getGoogleMapKey();

val version = OneS1ght.SDK_VERSION   // "0.0.11"

String version = OneS1ght.SDK_VERSION;

val profileId = OneS1ght.createProfile(mapOf("gender" to "F", "ageBand" to "20s"))

Map<String, String> attributes = new HashMap<>();
attributes.put("gender", "F");
attributes.put("ageBand", "20s");
OneS1ght.createProfile(attributes, new Callback<String>() {
    @Override public void onSuccess(String profileId) { }
    @Override public void onError(Throwable error) { }
});

OneS1ght.identify(profileId)

OneS1ght.identify(profileId);

val attributes = OneS1ght.fetchProfile(profileId)

OneS1ght.fetchProfile(profileId, new Callback<Map<String, String>>() {
    @Override public void onSuccess(Map<String, String> attributes) { }
    @Override public void onError(Throwable error) { }
});

OneS1ght.replaceProfile(profileId, mapOf("gender" to "F", "ageBand" to "30s"))

Map<String, String> attributes = new HashMap<>();
attributes.put("gender", "F");
attributes.put("ageBand", "30s");
OneS1ght.replaceProfile(profileId, attributes, new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

OneS1ght.deleteProfile(profileId)

OneS1ght.deleteProfile(profileId, new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

val buildings = OneS1ght.buildings()
val building = OneS1ght.building(id = buildingId)

OneS1ght.buildings(new Callback<List<Building>>() {
    @Override public void onSuccess(List<Building> buildings) { }
    @Override public void onError(Throwable error) { }
});

val floors = OneS1ght.floors(buildingId)

OneS1ght.floors(buildingId, new Callback<List<Floor>>() {
    @Override public void onSuccess(List<Floor> floors) { }
    @Override public void onError(Throwable error) { }
});

val floor = OneS1ght.floor(buildingId, floorId)
val png = floor.image   // ByteArray?

OneS1ght.floor(buildingId, floorId, new Callback<Floor>() {
    @Override public void onSuccess(Floor floor) { byte[] png = floor.getImage(); }
    @Override public void onError(Throwable error) { }
});

val zones = OneS1ght.zones(buildingId, floorId)
val zone = OneS1ght.zone(buildingId, floorId, zoneId)

OneS1ght.zones(buildingId, floorId, new Callback<List<Zone>>() {
    @Override public void onSuccess(List<Zone> zones) { }
    @Override public void onError(Throwable error) { }
});

val floorLocators = OneS1ght.locators(buildingId, floorId)
val ready = floorLocators.positioningReady

OneS1ght.locators(buildingId, floorId, new Callback<FloorLocators>() {
    @Override public void onSuccess(FloorLocators floorLocators) { }
    @Override public void onError(Throwable error) { }
});

val floor = OneS1ght.floor(buildingId, floorId)
OneS1ght.setFloorMap(floor, buildingId)

OneS1ght.floor(buildingId, floorId, new Callback<Floor>() {
    @Override public void onSuccess(Floor floor) {
        OneS1ght.setFloorMap(floor, buildingId, new Callback<Void>() {
            @Override public void onSuccess(Void result) { }
            @Override public void onError(Throwable error) { }
        });
    }
    @Override public void onError(Throwable error) { }
});

val zones = OneS1ght.refreshZones()

OneS1ght.refreshZones(new Callback<List<Zone>>() {
    @Override public void onSuccess(List<Zone> zones) { }
    @Override public void onError(Throwable error) { }
});

val session = OneS1ght.floorSession()

FloorSession session = OneS1ght.floorSession();

session.begin()

session.begin(new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

session.end()

session.end(new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

session.pause()
session.resume()

session.pause();
session.resume();

val running = session.isRunning
val paused = session.isPaused
val current = session.floor   // Floor?

boolean running = session.isRunning();
boolean paused = session.isPaused();
Floor current = session.getFloor();

session.onPosition = PositionListener { coordinates -> Log.d("OneS1ght", "${coordinates.x}, ${coordinates.y}") }

session.setOnPosition(coordinates -> Log.d("OneS1ght", coordinates.getX() + ", " + coordinates.getY()));

session.onZoneEnter = ZoneListener { zone -> Log.d("OneS1ght", "IN ${zone.name}") }
session.onZoneExit  = ZoneListener { zone -> Log.d("OneS1ght", "OUT ${zone.name}") }

session.setOnZoneEnter(zone -> Log.d("OneS1ght", "IN " + zone.getName()));
session.setOnZoneExit(zone -> Log.d("OneS1ght", "OUT " + zone.getName()));

session.onZoneDwell = DwellListener { zone, seconds -> Log.d("OneS1ght", "DWELL ${zone.name} ${seconds}s") }

session.setOnZoneDwell((zone, seconds) -> Log.d("OneS1ght", "DWELL " + zone.getName() + " " + seconds));

session.onTriggers = TriggersListener { zoneId, triggers ->
    triggers.forEach { trigger -> Log.d("OneS1ght", "${trigger.type} ${trigger.payload}") }
}

session.setOnTriggers((zoneId, triggers) -> {
    for (Trigger trigger : triggers) Log.d("OneS1ght", trigger.getType());
});

session.onFloorDetected = SessionFloorListener { floorId ->
    if (floorId == null) return@SessionFloorListener
    lifecycleScope.launch {
        val floor = OneS1ght.floor(buildingId, floorId)
        OneS1ght.setFloorMap(floor, buildingId)
    }
}

session.setOnFloorDetected(floorId -> {
    if (floorId == null) return;
    OneS1ght.floor(buildingId, floorId, new Callback<Floor>() {
        @Override public void onSuccess(Floor floor) {
            OneS1ght.setFloorMap(floor, buildingId, new Callback<Void>() {
                @Override public void onSuccess(Void result) { }
                @Override public void onError(Throwable error) { }
            });
        }
        @Override public void onError(Throwable error) { }
    });
});

session.onStopped = SessionStoppedListener { reason ->
    when (reason) {
        FloorSession.StopReason.ENDED         -> Unit
        FloorSession.StopReason.ENGINE_FAILED -> Unit
        else                                  -> Unit
    }
}

session.setOnStopped(reason -> {
    if (reason == FloorSession.StopReason.ENGINE_FAILED) { }
});

session.onConfigChanged = ConfigChangeListener { change ->
    when (change) {
        is ConfigChange.ZonesChanged, is ConfigChange.ResyncNeeded -> lifecycleScope.launch { OneS1ght.refreshZones() }
        is ConfigChange.PlanChanged -> redrawFloor()
        else -> Unit
    }
}

session.setOnConfigChanged(change -> {
    if (change instanceof ConfigChange.ZonesChanged || change instanceof ConfigChange.ResyncNeeded) {
        OneS1ght.refreshZones(new Callback<List<Zone>>() {
            @Override public void onSuccess(List<Zone> zones) { }
            @Override public void onError(Throwable error) { }
        });
    }
});

OneS1ght.uploadPendingPositions()

OneS1ght.uploadPendingPositions(new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) { }
});

OneS1ght.discardPendingPositions()

OneS1ght.discardPendingPositions();

try {
    OneS1ght.initialize(context = context.applicationContext, sdkKey = key)
} catch (e: SdkError) {
    Log.w("OneS1ght", e.code.code)                     // "E1003"
} catch (e: ApiError) {
    Log.w("OneS1ght", "${e.code.code} ${e.message}")   // "E5005 …"
}

OneS1ght.initialize(context, key, new Callback<Void>() {
    @Override public void onSuccess(Void result) { }
    @Override public void onError(Throwable error) {
        if (error instanceof SdkError) {
            Log.w("OneS1ght", ((SdkError) error).getCode().getCode());   // "E1003"
        } else if (error instanceof ApiError) {
            Log.w("OneS1ght", ((ApiError) error).getCode().getCode() + " " + error.getMessage());
        }
    }
});