import com.connectsdk.core.Util; //导入依赖的package包/类
private void loadMedia(com.google.android.gms.cast.MediaInfo mediaInformation,
                       final WebAppSession webAppSession, final LaunchListener listener) {
    try {
        mMediaPlayer.load(mApiClient, mediaInformation, true).setResultCallback(new ResultCallback<MediaChannelResult>() {

            @Override
            public void onResult(MediaChannelResult result) {
                Status status = result.getStatus();

                if (status.isSuccess()) {
                    webAppSession.launchSession.setSessionType(LaunchSessionType.Media);
                    mMediaPlayer.setActiveMediaTracks(mApiClient, new long[] { MEDIA_TRACK_ID });
                    Util.postSuccess(listener, new MediaLaunchObject(webAppSession.launchSession, CastService.this));
                }
                else {
                    Util.postError(listener, new ServiceCommandError(status.getStatusCode(), status.getStatusMessage(), status));
                }
            }
        });
    } catch (Exception e) {
        Util.postError(listener, new ServiceCommandError(0, "Unable to load", null));
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
protected void reportConnected(boolean ready) {
    if (listener == null)
        return;

    // only run callback on main thread if the callback is leaving the SDK
    if (listener instanceof ConnectableDevice)
        listener.onConnectionSuccess(this);
    else {
        Util.runOnUI(new Runnable() {
            @Override
            public void run() {
                if (listener != null)
                    listener.onConnectionSuccess(DeviceService.this);
            }
        });
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void onConnectionFailed(final ConnectionResult result) {
    Log.d(Util.T, "ConnectionFailedListener.onConnectionFailed " + (result != null ? result: ""));

    detachMediaPlayer();
    connected = false;
    mWaitingForReconnect = false;
    mApiClient = null;


    Util.runOnUI(new Runnable() {

        @Override
        public void run() {
            if (listener != null) {
                ServiceCommandError error = new ServiceCommandError(result.getErrorCode(), "Failed to connect to Google Cast device", result);

                listener.onConnectionFailure(CastService.this, error);
            }
        }
    });
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void connect(final ResponseListener<Object> listener) {
    if (castServiceChannel != null) {
        disconnectFromWebApp();
    }

    castServiceChannel = new CastServiceChannel(launchSession.getAppId(), this);

    try {
        Cast.CastApi.setMessageReceivedCallbacks(service.getApiClient(),
                castServiceChannel.getNamespace(),
                castServiceChannel);

        Util.postSuccess(listener, null);
    } catch (IOException e) {
        castServiceChannel = null;

        Util.postError(listener, new ServiceCommandError(0, "Failed to create channel", null));
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void launchNetflix(final String contentId, AppLaunchListener listener) {
    JSONObject params = null;

    if (contentId != null && contentId.length() > 0) {
        try {
            params = new JSONObject() {{
                put("v", contentId);
            }};
        } catch (JSONException e) {
            Log.e(Util.T, "Launch Netflix error", e);
        }
    }

    AppInfo appInfo = new AppInfo(APP_NETFLIX);
    appInfo.setName(appInfo.getId());

    launchAppWithInfo(appInfo, params, listener);
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void sendKeyCode(KeyCode keycode, ResponseListener<Object> listener) {
    switch (keycode) {
        case NUM_0:
        case NUM_1:
        case NUM_2:
        case NUM_3:
        case NUM_4:
        case NUM_5:
        case NUM_6:
        case NUM_7:
        case NUM_8:
        case NUM_9:
            sendSpecialKey(String.valueOf(keycode.getCode()), listener);
            break;
        case DASH:
            sendSpecialKey("DASH", listener);
            break;
        case ENTER:
            sendSpecialKey("ENTER", listener);
        default:
            Util.postError(listener, new ServiceCommandError(0, "The keycode is not available", null));
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void launchAppWithInfo(final AppInfo appInfo, Object params, final AppLaunchListener listener) {
    ServiceCommand<ResponseListener<Object>> command = new ServiceCommand<ResponseListener<Object>>(this, requestURL(appInfo.getName()), params, new ResponseListener<Object>() {
        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, new ServiceCommandError(0, "Problem Launching app", null));
        }

        @Override
        public void onSuccess(Object object) {
            LaunchSession launchSession = LaunchSession.launchSessionForAppId(appInfo.getId());
            launchSession.setAppName(appInfo.getName());
            launchSession.setSessionId((String)object);
            launchSession.setService(DIALService.this);
            launchSession.setSessionType(LaunchSessionType.App);

            Util.postSuccess(listener, launchSession);
        }
    });

    command.send();
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
private void getTotalNumberOfApplications(int type, final AppCountListener listener) {
    ResponseListener<Object> responseListener = new ResponseListener<Object>() {

        @Override
        public void onSuccess(Object response) {
            String strObj = (String) response;

            int applicationNumber = parseAppNumberXmlToJSON(strObj);

            Util.postSuccess(listener, applicationNumber);
        }

        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, error);
        }
    };

    String requestURL = getUDAPRequestURL(UDAP_PATH_DATA, TARGET_APPNUM_GET, String.valueOf(type));

    ServiceCommand<ResponseListener<Object>> command = new ServiceCommand<ResponseListener<Object>>(this, requestURL, null, responseListener);
    command.setHttpMethod(ServiceCommand.TYPE_GET);
    command.send();
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void getVolume(final VolumeListener listener) {

    getVolumeStatus(new VolumeStatusListener() {

        @Override
        public void onSuccess(VolumeStatus status) {
            Util.postSuccess(listener, status.volume);
        }

        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, error);
        }
    });

}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
public void requestStatus(final ResponseListener<Object> listener) {
    try {
        mMediaPlayer
                .requestStatus(mApiClient)
                .setResultCallback(
                        new ResultCallback<RemoteMediaPlayer.MediaChannelResult>() {

                            @Override
                            public void onResult(MediaChannelResult result) {
                                if (result.getStatus().isSuccess()) {
                                    Util.postSuccess(listener, result);
                                }
                                else {
                                    Util.postError(listener, new ServiceCommandError(0, "Failed to request status", result));
                                }
                            }
                        });
    } catch (Exception e) {
        Util.postError(listener, new ServiceCommandError(0, "There is no media currently available", null));
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void sendMessage(String message, final ResponseListener<Object> listener) {
    if (message == null) {
        Util.postError(listener, new ServiceCommandError(0, "Cannot send null message", null));
        return;
    }

    if (castServiceChannel == null) {
        Util.postError(listener, new ServiceCommandError(0, "Cannot send a message to the web app without first connecting", null));
        return;
    }

    Cast.CastApi.sendMessage(service.getApiClient(), castServiceChannel.getNamespace(), message).setResultCallback(new ResultCallback<Status>() {

        @Override
        public void onResult(Status result) {
            if (result.isSuccess()) {
                Util.postSuccess(listener, null);
            }
            else {
                Util.postError(listener, new ServiceCommandError(result.getStatusCode(), result.toString(), result));
            }
        }
    });
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
public void getLaunchPoints(final LaunchPointsListener listener) {
    String uri = "ssap://com.webos.applicationManager/listLaunchPoints";

    ResponseListener<Object> responseListener = new ResponseListener<Object>() {

        @Override
        public void onSuccess(Object response) {

            try {
                JSONObject jsonObj = (JSONObject) response;
                JSONArray launchPoints = (JSONArray) jsonObj.get("launchPoints");
                Util.postSuccess(listener, launchPoints);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, error);
        }
    };

    ServiceCommand<ResponseListener<Object>> request = new ServiceCommand<ResponseListener<Object>>(this, uri, null, true, responseListener);
    request.send();
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
private void store() {
    updated = Util.getTime();

    JSONObject deviceStore = new JSONObject();
    try {
        deviceStore.put(KEY_VERSION, version);
        deviceStore.put(KEY_CREATED, created);
        deviceStore.put(KEY_UPDATED, updated);
        JSONArray deviceArray = new JSONArray(storedDevices.values());
        deviceStore.put(KEY_DEVICES, deviceArray);
    } catch (JSONException e) {
        e.printStackTrace();
    }

    if (!waitToWrite)
        writeStoreToDisk(deviceStore);
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void launchHulu(final String contentId, final Launcher.AppLaunchListener listener) {
    final String appName = "Hulu";

    getApplication(appName, new AppInfoListener() {

        @Override
        public void onSuccess(AppInfo appInfo) {
            launchApplication(appName, appInfo.getId(), contentId, listener);
        }

        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, error);
        }
    });
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
protected void pickFailed(final ConnectableDevice device) {
    Util.runOnUI(new Runnable() {
        @Override
        public void run() {
            if (pendingDevice == device) {
                // Device failed before successfully picking device
                if (listener != null) {
                    listener.onPickDeviceFailed(false);
                }
            }

            cleanupPending();

            Toast.makeText(activity, connectionFailedResId, Toast.LENGTH_SHORT).show();
        }
    });
}
 

import com.connectsdk.core.Util; //导入依赖的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.core.Util; //导入依赖的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.core.Util; //导入依赖的package包/类
@Override
public ServiceSubscription<PlayStateListener> subscribePlayState(
        final PlayStateListener listener) {
    if (mPlayStateSubscription == null)
        mPlayStateSubscription = new URLServiceSubscription<MediaControl.PlayStateListener>(
                null, null, null, null);

    if (!connected) {
        connect(new ResponseListener<Object>() {

            @Override
            public void onError(ServiceCommandError error) {
                Util.postError(listener, error);
            }

            @Override
            public void onSuccess(Object response) {
            }
        });
    }

    if (!mPlayStateSubscription.getListeners().contains(listener))
        mPlayStateSubscription.addListener(listener);

    return mPlayStateSubscription;
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void serviceRemoved(ServiceEvent ev) {
    @SuppressWarnings("deprecation")
    String uuid = ev.getInfo().getHostAddress();
    final ServiceDescription service = foundServices.get(uuid);

    if (service != null) {
        Util.runOnUI(new Runnable() {

            @Override
            public void run() {
                for (DiscoveryProviderListener listener : serviceListeners) {
                    listener.onServiceRemoved(ZeroconfDiscoveryProvider.this, service);
                }
            }
        });
    }
}
 

import com.connectsdk.core.Util; //导入依赖的package包/类
@Override
public void joinWebApp(final LaunchSession webAppLaunchSession, final WebAppSession.LaunchListener listener) {
    final WebOSWebAppSession webAppSession = this.webAppSessionForLaunchSession(webAppLaunchSession);

    webAppSession.join(new ResponseListener<Object>() {

        @Override
        public void onError(ServiceCommandError error) {
            Util.postError(listener, error);
        }

        @Override
        public void onSuccess(Object object) {
            Util.postSuccess(listener, webAppSession);
        }
    });
}