import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Override
public ServiceConfig getServiceConfig(ServiceDescription serviceDescription) {
    if (serviceDescription == null) {
        return null;            
    }
    String uuid = serviceDescription.getUUID();
    if (uuid == null || uuid.length() == 0) {
        return null;
    }

    JSONObject device = getStoredDevice(uuid);
    if (device != null) {
        JSONObject services = device.optJSONObject(ConnectableDevice.KEY_SERVICES);
        if (services != null) {
            JSONObject service = services.optJSONObject(uuid);
            if (service != null) {
                JSONObject serviceConfigInfo = service.optJSONObject(DeviceService.KEY_CONFIG);
                if (serviceConfigInfo != null) {
                    return ServiceConfig.getConfig(serviceConfigInfo);
                }
            }
        }
    }

    return null;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Adds a DeviceService to the ConnectableDevice instance. Only one instance of each DeviceService type (webOS, Netcast, etc) may be attached to a single ConnectableDevice instance. If a device contains your service type already, your service will not be added.
 * 
 * @param service DeviceService to be added
 */
public void addService(DeviceService service) {
    final List<String> added = getMismatchCapabilities(service.getCapabilities(), getCapabilities());

    service.setListener(this);

    Util.runOnUI(new Runnable() {

        @Override
        public void run() {
            for (ConnectableDeviceListener listener : listeners)
                listener.onCapabilityUpdated(ConnectableDevice.this, added, new ArrayList<String>());
        }
    });

    services.put(service.getServiceName(), service);
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Removes a DeviceService from the ConnectableDevice instance.
 * 
 * @param serviceId ID of the DeviceService to be removed (DLNA, webOS TV, etc)
 */
public void removeServiceWithId(String serviceId) {
    DeviceService service = services.get(serviceId);

    if (service == null)
        return;

    service.disconnect();

    services.remove(serviceId);

    final List<String> removed = getMismatchCapabilities(service.getCapabilities(), getCapabilities());

    Util.runOnUI(new Runnable() {

        @Override
        public void run() {
            for (ConnectableDeviceListener listener : listeners)
                listener.onCapabilityUpdated(ConnectableDevice.this, new ArrayList<String>(), removed);
        }
    });
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
public boolean isConnected() {
    int connectedCount = 0;

    Iterator<DeviceService> iterator = services.values().iterator();

    while (iterator.hasNext()) {
        DeviceService service = iterator.next();

        if (!service.isConnectable()) {
            connectedCount++;
        } else {
            if (service.isConnected())
                connectedCount++;
        }
    }

    return connectedCount >= services.size();
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
public JSONObject toJSONObject() {
    JSONObject deviceObject = new JSONObject();

    try {
        deviceObject.put(KEY_ID, getId());
        deviceObject.put(KEY_LAST_IP, getIpAddress());
        deviceObject.put(KEY_FRIENDLY, getFriendlyName());
        deviceObject.put(KEY_MODEL_NAME, getModelName());
        deviceObject.put(KEY_MODEL_NUMBER, getModelNumber());
        deviceObject.put(KEY_LAST_SEEN, getLastSeenOnWifi());
        deviceObject.put(KEY_LAST_CONNECTED, getLastConnected());
        deviceObject.put(KEY_LAST_DETECTED, getLastDetection());

        JSONObject jsonServices = new JSONObject();
        for (DeviceService service: services.values()) {
            JSONObject serviceObject = service.toJSONObject();

            jsonServices.put(service.getServiceConfig().getServiceUUID(), serviceObject);
        }
        deviceObject.put(KEY_SERVICES, jsonServices);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    return deviceObject;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Override
public void onConnectionSuccess(DeviceService service) {
    //  TODO: iOS is passing to a function for when each service is ready on a device.  This is not implemented on Android.

    if (isConnected()) {
        ConnectableDeviceStore deviceStore = DiscoveryManager.getInstance().getConnectableDeviceStore();
        if (deviceStore != null) {
            deviceStore.addDevice(this);
        }

        Util.runOnUI(new Runnable() {

            @Override
            public void run() {
                for (ConnectableDeviceListener listener : listeners)
                    listener.onDeviceReady(ConnectableDevice.this);
            }
        });

        setLastConnected(Util.getTime());
    }
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Test
public void testSetPromptPairingType() throws IOException {
    // given
    addAllCoreServicesToDevice();

    // when
    device.setPairingType(DeviceService.PairingType.FIRST_SCREEN);

    // then
    Assert.assertEquals(DeviceService.PairingType.FIRST_SCREEN, device.getServiceByName(WebOSTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(NetcastTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DLNAService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DIALService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(RokuService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(AirPlayService.ID).getPairingType());
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Test
public void testSetPinPairingType() throws IOException {
    // given
    addAllCoreServicesToDevice();

    // when
    device.setPairingType(DeviceService.PairingType.PIN_CODE);

    // then
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(WebOSTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(NetcastTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DLNAService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DIALService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(RokuService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(AirPlayService.ID).getPairingType());
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Test
public void testNonePairingType() throws IOException {
    // given
    addAllCoreServicesToDevice();

    // when
    device.setPairingType(DeviceService.PairingType.NONE);

    // then
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(WebOSTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(NetcastTVService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DLNAService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(DIALService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.NONE, device.getServiceByName(RokuService.ID).getPairingType());
    Assert.assertEquals(DeviceService.PairingType.PIN_CODE, device.getServiceByName(AirPlayService.ID).getPairingType());
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Override
public void onPairingRequired(ConnectableDevice device, DeviceService service, DeviceService.PairingType pairingType) {
    switch (pairingType) {
        case FIRST_SCREEN:
            mPairingAlertDialog.show();
            break;
        case PIN_CODE:
            mPairingCodeDialog.show();
            break;
        case NONE:
        default:
            break;
    }

    for(ConnectableDeviceListener listener : mDeviceListeners)
        listener.onPairingRequired(device, service, pairingType);
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Override
public void updateDevice(ConnectableDevice device) {
    if (device == null || device.getServices().size() == 0)
        return;

    JSONObject storedDevice = getStoredDevice(device.getId());

    if (storedDevice == null)
        return;

    try {
        storedDevice.put(ConnectableDevice.KEY_LAST_IP, device.getLastKnownIPAddress());
        storedDevice.put(ConnectableDevice.KEY_LAST_SEEN, device.getLastSeenOnWifi());
        storedDevice.put(ConnectableDevice.KEY_LAST_CONNECTED, device.getLastConnected());
        storedDevice.put(ConnectableDevice.KEY_LAST_DETECTED, device.getLastDetection());

        JSONObject services = storedDevice.optJSONObject(ConnectableDevice.KEY_SERVICES);

        if (services == null)
            services = new JSONObject();

        for (DeviceService service : device.getServices()) {
            JSONObject serviceInfo = service.toJSONObject();

            if (serviceInfo != null)
                services.put(service.getServiceDescription().getUUID(), serviceInfo);
        }

        storedDevice.put(ConnectableDevice.KEY_SERVICES, services);

        storedDevices.put(device.getId(), storedDevice);
        activeDevices.put(device.getId(), device);

        store();
    } catch (JSONException e) {
        e.printStackTrace();
    }
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
private ConnectableDevice getActiveDevice(String uuid) {
    ConnectableDevice foundDevice = activeDevices.get(uuid);

    if (foundDevice == null) {
        for (ConnectableDevice device : activeDevices.values()) {
            for (DeviceService service : device.getServices()) {
                if (uuid.equals(service.getServiceDescription().getUUID())) {
                    return device;
                }
            }
        }
    }
    return foundDevice;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
@Override
public void onPairingRequired(ConnectableDevice device, DeviceService service, final PairingType pairingType) {
    Log.d("SimpleDevicePicker", "pairing required for device " + device.getFriendlyName());

    Util.runOnUI(new Runnable() {
        @Override
        public void run() {
            showPairingDialog(pairingType);
        }
    });
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * set desirable pairing type for all services
 * @param pairingType
 */
public void setPairingType(PairingType pairingType) {
    Collection<DeviceService> services = getServices();
    for (DeviceService service : services) {
        service.setPairingType(pairingType);
    }
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Obtains a service from the ConnectableDevice with the provided serviceName
 *
 * @param serviceName Service ID of the targeted DeviceService (webOS, Netcast, DLNA, etc)
 * @return DeviceService with the specified serviceName or nil, if none exists
 */
public DeviceService getServiceByName(String serviceName) {
    for (DeviceService service : getServices()) {
        if (service.getServiceName().equals(serviceName)) {
            return service;
        }
    }

    return null;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Returns a DeviceService from the ConnectableDevice instance. serviceUUID is used as the identifier because only one instance of each DeviceService type may be attached to a single ConnectableDevice instance.
 * 
 * @param serviceUUID UUID of the DeviceService to be returned
 */
public DeviceService getServiceWithUUID(String serviceUUID) {
    for (DeviceService service : getServices()) {
        if (service.getServiceDescription().getUUID().equals(serviceUUID)) {
            return service;
        }
    }

    return null;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Enumerates through all DeviceServices and attempts to connect to each of them. When all of a ConnectableDevice's DeviceServices are ready to receive commands, the ConnectableDevice will send a onDeviceReady message to its listener.
 *
 * It is always necessary to call connect on a ConnectableDevice, even if it contains no connectable DeviceServices.
 */
public void connect() {
    for (DeviceService service : services.values()) {
        if (!service.isConnected()) {
            service.connect();
        }
    }
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Enumerates through all DeviceServices and attempts to disconnect from each of them.
 */
public void disconnect() {
    for (DeviceService service: services.values()) {
        service.disconnect();
    }

    Util.runOnUI(new Runnable() {

        @Override
        public void run() {
            for (ConnectableDeviceListener listener : listeners)
                listener.onDeviceDisconnected(ConnectableDevice.this);
        }
    });
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/**
 * Whether the device has any DeviceServices that require an active connection (websocket, HTTP registration, etc)
 */
public boolean isConnectable() {
    for (DeviceService service: services.values()) {
        if (service.isConnectable())
            return true;
    }

    return false;
}
 

import com.connectsdk.service.DeviceService; //导入依赖的package包/类
/** A combined list of all capabilities that are supported among the detected DeviceServices. */
public synchronized List<String> getCapabilities() {
    List<String> caps = new ArrayList<String>();

    for (DeviceService service: services.values()) {
        for (String capability: service.getCapabilities()) {
            if (!caps.contains(capability)) {
                caps.add(capability);
            }
        }
    }

    return caps;
}