Youtube live stream to specific Channel

Question

I am using the below code to create event in Youtube for Live Streaming. Everything works fine, my problem, I want users to live stream to our company's Channel.

At present events are getting created in users channel, this is wrong, we want to create the event in our channel and live stream should come to our company's channel. I would like to know how we should specify our company's channel to create the events.

I tried to specify

YouTube.LiveBroadcasts.Insert liveBroadcastInsert = youtube
                .liveBroadcasts().insert(Arrays.asList(lbInsert),
                        broadcast);

liveBroadcastInsert.onBehalfOfContentOwner("[email protected]");
liveBroadcastInsert.onBehalfOfContentOwnerChannel("ChannelID");

Both did not work. It gave error

"errors": [
{
  "domain": "youtube.common",
  "message": "The authenticated user cannot act on behalf of the specified Google account.",
  "reason": "accountDelegationForbidden"
}

//// Code ///

import com.google.android.gms.common.Scopes;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.util.DateTime;
import com.google.api.services.youtube.YouTube;
import com.google.api.services.youtube.YouTube.LiveBroadcasts.Transition;
import com.google.api.services.youtube.YouTubeScopes;
import com.google.api.services.youtube.model.CdnSettings;
import com.google.api.services.youtube.model.ChannelListResponse;
import com.google.api.services.youtube.model.IngestionInfo;
import com.google.api.services.youtube.model.LiveBroadcast;
import com.google.api.services.youtube.model.LiveBroadcastContentDetails;
import com.google.api.services.youtube.model.LiveBroadcastListResponse;
import com.google.api.services.youtube.model.LiveBroadcastSnippet;
import com.google.api.services.youtube.model.LiveBroadcastStatus;
import com.google.api.services.youtube.model.LiveStream;
import com.google.api.services.youtube.model.LiveStreamListResponse;
import com.google.api.services.youtube.model.LiveStreamSnippet;
import com.google.api.services.youtube.model.MonitorStreamInfo;
import com.test.tv.usb.MainActivity;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

public class YouTubeApi {

    public static final String RTMP_URL_KEY = "rtmpUrl";
    public static final String BROADCAST_ID_KEY = "broadcastId";
    private static final int FUTURE_DATE_OFFSET_MILLIS = 5 * 1000;

    public static void createLiveEvent(YouTube youtube, String description,
                                       String name) {
        // We need a date that's in the proper ISO format and is in the future,
        // since the API won't
        // create events that start in the past.

        SimpleDateFormat dateFormat = new SimpleDateFormat(
                "yyyy-MM-dd'T'HH:mm:ss'Z'");
        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        long futureDateMillis = System.currentTimeMillis()
                + FUTURE_DATE_OFFSET_MILLIS;
        Date futureDate = new Date();
        futureDate.setTime(futureDateMillis);
        String date = dateFormat.format(futureDate);

        Log.i(MainActivity.APP_NAME, String.format(
                "Creating event: name='%s', description='%s', date='%s'.",
                name, description, date));

        try {

            LiveBroadcastSnippet broadcastSnippet = new LiveBroadcastSnippet();
            broadcastSnippet.setTitle(name);
            broadcastSnippet.setScheduledStartTime(new DateTime(futureDate));

            LiveBroadcastContentDetails contentDetails = new LiveBroadcastContentDetails();
            MonitorStreamInfo monitorStream = new MonitorStreamInfo();
            monitorStream.setEnableMonitorStream(false);
            contentDetails.setMonitorStream(monitorStream);

            // Create LiveBroadcastStatus with privacy status.
            LiveBroadcastStatus status = new LiveBroadcastStatus();
            status.setPrivacyStatus("public");

            LiveBroadcast broadcast = new LiveBroadcast();
            broadcast.setKind("youtube#liveBroadcast");
            broadcast.setSnippet(broadcastSnippet);
            broadcast.setStatus(status);
            broadcast.setContentDetails(contentDetails);

            // Create the insert request
            String[] lbInsert = {"snippet", "status","contentDetails"};

            YouTube.LiveBroadcasts.Insert liveBroadcastInsert = youtube
                    .liveBroadcasts().insert(Arrays.asList(lbInsert),
                            broadcast);


            // Request is executed and inserted broadcast is returned
            LiveBroadcast returnedBroadcast = liveBroadcastInsert.execute();

            // Create a snippet with title.
            LiveStreamSnippet streamSnippet = new LiveStreamSnippet();
            streamSnippet.setTitle(name);

            // Create content distribution network with format and ingestion
            // type.
            CdnSettings cdn = new CdnSettings();
            cdn.setIngestionType("rtmp");
            cdn.setResolution("1080p");
            cdn.setFrameRate("30fps");

            LiveStream stream = new LiveStream();
            stream.setKind("youtube#liveStream");
            stream.setSnippet(streamSnippet);
            stream.setCdn(cdn);

            // Create the insert request
            String[] lsInsert = {"snippet", "cdn"};
            YouTube.LiveStreams.Insert liveStreamInsert = youtube.liveStreams()
                    .insert(Arrays.asList(lsInsert), stream);

            // Request is executed and inserted stream is returned
            LiveStream returnedStream = liveStreamInsert.execute();

            // Create the bind request
            String[] lbBind = {"id", "contentDetails"};
            YouTube.LiveBroadcasts.Bind liveBroadcastBind = youtube
                    .liveBroadcasts().bind(returnedBroadcast.getId(),
                            Arrays.asList(lbBind));

            // Set stream id to bind
            liveBroadcastBind.setStreamId(returnedStream.getId());

            // Request is executed and bound broadcast is returned
            liveBroadcastBind.execute();

        } catch (GoogleJsonResponseException e) {
            System.err.println("GoogleJsonResponseException code: "
                    + e.getDetails().getCode() + " : "
                    + e.getDetails().getMessage());
            e.printStackTrace();

        } catch (IOException e) {
            System.err.println("IOException: " + e.getMessage());
            e.printStackTrace();
        } catch (Throwable t) {
            System.err.println("Throwable: " + t.getStackTrace());
            t.printStackTrace();
        }
    }

    // TODO: Catch those exceptions and handle them here.
    public static List<EventData> getLiveEvents(
            YouTube youtube) throws IOException {
            Log.i(MainActivity.APP_NAME, "Requesting live events.");
            
            String[] yReq = {"id", "snippet", "contentDetails"};
            YouTube.LiveBroadcasts.List liveBroadcastRequest = youtube
                    .liveBroadcasts().list(Arrays.asList(yReq));
            // liveBroadcastRequest.setMine(true);
            liveBroadcastRequest.setBroadcastStatus("upcoming");

            // List request is executed and list of broadcasts are returned
            LiveBroadcastListResponse returnedListResponse = liveBroadcastRequest.execute();

            // Get the list of broadcasts associated with the user.
            List<LiveBroadcast> returnedList = returnedListResponse.getItems();

            List<EventData> resultList = new ArrayList<EventData>(returnedList.size());
            EventData event;

            for (LiveBroadcast broadcast : returnedList) {
                event = new EventData();
                event.setEvent(broadcast);
                String streamId = broadcast.getContentDetails().getBoundStreamId();
                if (streamId != null) {
                    String[] strID = {streamId};
                    String ingestionAddress = getIngestionAddress(youtube, strID);
                    event.setIngestionAddress(ingestionAddress);
                }
                resultList.add(event);
            }
            return resultList;
    }

    public static void startEvent(YouTube youtube, String broadcastId)
            throws IOException {

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Log.e(MainActivity.APP_NAME, "", e);
        }
        String[] tReq = {"status"};
        Transition transitionRequest = youtube.liveBroadcasts().transition(
                "live", broadcastId, Arrays.asList(tReq));
        transitionRequest.execute();
    }

    public static void endEvent(YouTube youtube, String broadcastId)
            throws IOException {
        String[] tReq = {"status"};
        Transition transitionRequest = youtube.liveBroadcasts().transition(
                "complete", broadcastId, Arrays.asList(tReq));
        transitionRequest.execute();
    }

    public static String getIngestionAddress(YouTube youtube, String[] streamId)
            throws IOException {
        String[] tReq = {"cdn"};
        YouTube.LiveStreams.List liveStreamRequest = youtube.liveStreams()
                .list(Arrays.asList(tReq));
        liveStreamRequest.setId(Arrays.asList(streamId));
        LiveStreamListResponse returnedStream = liveStreamRequest.execute();

        List<LiveStream> streamList = returnedStream.getItems();
        if (streamList.isEmpty()) {
            return "";
        }
        IngestionInfo ingestionInfo = streamList.get(0).getCdn().getIngestionInfo();
        return ingestionInfo.getIngestionAddress() + "/"
                + ingestionInfo.getStreamName();
    }
}