/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.tv.samples.sampletvinteractiveappservice;

import android.annotation.TargetApi;
import android.app.Presentation;
import android.content.Context;
import android.content.Intent;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.ColorDrawable;
import android.hardware.display.DisplayManager;
import android.hardware.display.VirtualDisplay;
import android.media.MediaPlayer;
import android.media.tv.AdRequest;
import android.media.tv.AdResponse;
import android.media.tv.BroadcastInfoRequest;
import android.media.tv.BroadcastInfoResponse;
import android.media.tv.SectionRequest;
import android.media.tv.SectionResponse;
import android.media.tv.StreamEventRequest;
import android.media.tv.StreamEventResponse;
import android.media.tv.TableRequest;
import android.media.tv.TableResponse;
import android.media.tv.TvTrackInfo;
import android.media.tv.interactive.AppLinkInfo;
import android.media.tv.interactive.TvInteractiveAppManager;
import android.media.tv.interactive.TvInteractiveAppService;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.ParcelFileDescriptor;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.VideoView;

import androidx.annotation.NonNull;

import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TiasSessionImpl extends TvInteractiveAppService.Session {
    private static final String TAG = "SampleTvInteractiveAppService";
    private static final boolean DEBUG = true;

    private static final String VIRTUAL_DISPLAY_NAME = "sample_tias_display";

    // For testing purposes, limit the number of response for a single request
    private static final int MAX_HANDLED_RESPONSE = 3;

    private final Context mContext;
    private TvInteractiveAppManager mTvIAppManager;
    private final Handler mHandler;
    private final String mAppServiceId;
    private final int mType;
    private final ViewGroup mViewContainer;
    private Surface mSurface;
    private VirtualDisplay mVirtualDisplay;
    private List<TvTrackInfo> mTracks;

    private TextView mTvInputIdView;
    private TextView mChannelUriView;
    private TextView mVideoTrackView;
    private TextView mAudioTrackView;
    private TextView mSubtitleTrackView;
    private TextView mLogView;

    private VideoView mVideoView;
    private SurfaceView mAdSurfaceView;
    private Surface mAdSurface;
    private ParcelFileDescriptor mAdFd;
    private FrameLayout mMediaContainer;
    private int mAdState;
    private int mWidth;
    private int mHeight;
    private int mScreenWidth;
    private int mScreenHeight;
    private String mCurrentTvInputId;
    private Uri mCurrentChannelUri;
    private String mSelectingAudioTrackId;
    private String mFirstAudioTrackId;
    private int mGeneratedRequestId = 0;
    private boolean mRequestStreamEventFinished = false;
    private int mSectionReceived = 0;
    private List<String> mStreamDataList = new ArrayList<>();
    private boolean mIsFullScreen = true;

    public TiasSessionImpl(Context context, String iAppServiceId, int type) {
        super(context);
        if (DEBUG) {
            Log.d(TAG, "Constructing service with iAppServiceId=" + iAppServiceId
                    + " type=" + type);
        }
        mContext = context;
        mAppServiceId = iAppServiceId;
        mType = type;
        mHandler = new Handler(context.getMainLooper());
        mTvIAppManager = (TvInteractiveAppManager) mContext.getSystemService(
                Context.TV_INTERACTIVE_APP_SERVICE);

        mViewContainer = new LinearLayout(context);
        mViewContainer.setBackground(new ColorDrawable(0));
    }

    @Override
    public View onCreateMediaView() {
        mAdSurfaceView = new SurfaceView(mContext);
        if (DEBUG) {
            Log.d(TAG, "create surfaceView");
        }
        mAdSurfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
        mAdSurfaceView
                .getHolder()
                .addCallback(
                        new SurfaceHolder.Callback() {
                            @Override
                            public void surfaceCreated(SurfaceHolder holder) {
                                mAdSurface = holder.getSurface();
                            }

                            @Override
                            public void surfaceChanged(
                                    SurfaceHolder holder, int format, int width, int height) {
                                mAdSurface = holder.getSurface();
                            }

                            @Override
                            public void surfaceDestroyed(SurfaceHolder holder) {}
                        });
        mAdSurfaceView.setVisibility(View.INVISIBLE);
        ViewGroup.LayoutParams layoutParams =
                new ViewGroup.LayoutParams(
                        ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
        mAdSurfaceView.setLayoutParams(layoutParams);
        mMediaContainer.addView(mVideoView);
        mMediaContainer.addView(mAdSurfaceView);
        return mMediaContainer;
    }

    @Override
    public void onAdResponse(AdResponse adResponse) {
        mAdState = adResponse.getResponseType();
        switch (mAdState) {
            case AdResponse.RESPONSE_TYPE_PLAYING:
                long time = adResponse.getElapsedTimeMillis();
                updateLogText("AD is playing. " + time);
                break;
            case AdResponse.RESPONSE_TYPE_STOPPED:
                updateLogText("AD is stopped.");
                mAdSurfaceView.setVisibility(View.INVISIBLE);
                break;
            case AdResponse.RESPONSE_TYPE_FINISHED:
                updateLogText("AD is play finished.");
                mAdSurfaceView.setVisibility(View.INVISIBLE);
                break;
        }
    }

    @Override
    public void onRelease() {
        if (DEBUG) {
            Log.d(TAG, "onRelease");
        }
        if (mSurface != null) {
            mSurface.release();
            mSurface = null;
        }
        if (mVirtualDisplay != null) {
            mVirtualDisplay.release();
            mVirtualDisplay = null;
        }
    }

    @Override
    public boolean onSetSurface(Surface surface) {
        if (DEBUG) {
            Log.d(TAG, "onSetSurface");
        }
        if (mSurface != null) {
            mSurface.release();
        }
        updateSurface(surface, mWidth, mHeight);
        mSurface = surface;
        return true;
    }

    @Override
    public void onSurfaceChanged(int format, int width, int height) {
        if (DEBUG) {
            Log.d(TAG, "onSurfaceChanged format=" + format + " width=" + width +
                    " height=" + height);
        }
        if (mSurface != null) {
            updateSurface(mSurface, width, height);
            mWidth = width;
            mHeight = height;
        }
    }

    @Override
    public void onStartInteractiveApp() {
        if (DEBUG) {
            Log.d(TAG, "onStartInteractiveApp");
        }
        mHandler.post(
                () -> {
                    initSampleView();
                    setMediaViewEnabled(true);
                    requestCurrentTvInputId();
                    requestCurrentChannelUri();
                    requestTrackInfoList();
                }
        );
    }

    @Override
    public void onStopInteractiveApp() {
        if (DEBUG) {
            Log.d(TAG, "onStopInteractiveApp");
        }
    }

    public void prepare(TvInteractiveAppService serviceCaller) {
        // Slightly delay our post to ensure the Manager has had time to register our Session
        mHandler.postDelayed(
                () -> {
                    if (serviceCaller != null) {
                        serviceCaller.notifyStateChanged(mType,
                                TvInteractiveAppManager.SERVICE_STATE_READY,
                                TvInteractiveAppManager.ERROR_NONE);
                    }
                },
                100);
    }

    @Override
    public boolean onKeyDown(int keyCode, @NonNull KeyEvent event) {
        // TODO: use a menu view instead of key events for the following tests
        switch (keyCode) {
            case KeyEvent.KEYCODE_PROG_RED:
                tuneToNextChannel();
                return true;
            case KeyEvent.KEYCODE_A:
                updateLogText("stop video broadcast begin");
                tuneChannelByType(
                        TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_STOP,
                        mCurrentTvInputId,
                        null);
                updateLogText("stop video broadcast end");
                return true;
            case KeyEvent.KEYCODE_B:
                updateLogText("resume video broadcast begin");
                tuneChannelByType(
                        TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE,
                        mCurrentTvInputId,
                        mCurrentChannelUri);
                updateLogText("resume video broadcast end");
                return true;
            case KeyEvent.KEYCODE_C:
                updateLogText("unselect audio track");
                mSelectingAudioTrackId = null;
                selectTrack(TvTrackInfo.TYPE_AUDIO, null);
                return true;
            case KeyEvent.KEYCODE_D:
                updateLogText("select audio track " + mFirstAudioTrackId);
                mSelectingAudioTrackId = mFirstAudioTrackId;
                selectTrack(TvTrackInfo.TYPE_AUDIO, mFirstAudioTrackId);
                return true;
            case KeyEvent.KEYCODE_E:
                if (mVideoView != null) {
                    if (mVideoView.isPlaying()) {
                        updateLogText("stop media");
                        mVideoView.stopPlayback();
                        mVideoView.setVisibility(View.GONE);
                        tuneChannelByType(
                                TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE,
                                mCurrentTvInputId,
                                mCurrentChannelUri);
                    } else {
                        updateLogText("play media");
                        tuneChannelByType(
                                TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_STOP,
                                mCurrentTvInputId,
                                null);
                        mVideoView.setVisibility(View.VISIBLE);
                        // TODO: put a file sample.mp4 in res/raw/ and use R.raw.sample for the URI
                        Uri uri = Uri.parse(
                                "android.resource://" + mContext.getPackageName() + "/");
                        mVideoView.setVideoURI(uri);
                        mVideoView.start();
                        updateLogText("media is playing");
                    }
                }
                return true;
            case KeyEvent.KEYCODE_F:
                updateLogText("request StreamEvent");
                mRequestStreamEventFinished = false;
                mStreamDataList.clear();
                // TODO: build target URI instead of using channel URI
                requestStreamEvent(
                        mCurrentChannelUri == null ? null : mCurrentChannelUri.toString(),
                        "event1");
                return true;
            case KeyEvent.KEYCODE_G:
                updateLogText("change video bounds");
                if (mIsFullScreen) {
                    setVideoBounds(new Rect(100, 150, 960, 540));
                    updateLogText("Change video broadcast size(100, 150, 960, 540)");
                    mIsFullScreen = false;
                } else {
                    setVideoBounds(new Rect(0, 0, mScreenWidth, mScreenHeight));
                    updateLogText("Change video broadcast full screen");
                    mIsFullScreen = true;
                }
                return true;
            case KeyEvent.KEYCODE_H:
                updateLogText("request section");
                mSectionReceived = 0;
                requestSection(false, 0, 0x0, -1);
                return true;
            case KeyEvent.KEYCODE_I:
                if (mTvIAppManager == null) {
                    updateLogText("TvIAppManager null");
                    return false;
                }
                List<AppLinkInfo> appLinks = getAppLinkInfoList();
                if (appLinks.isEmpty()) {
                    updateLogText("Not found AppLink");
                } else {
                    AppLinkInfo appLink = appLinks.get(0);
                    Intent intent = new Intent();
                    intent.setComponent(appLink.getComponentName());
                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    mContext.getApplicationContext().startActivity(intent);
                    updateLogText("Launch " + appLink.getComponentName());
                }
                return true;
            case KeyEvent.KEYCODE_J:
                updateLogText("Request SI Tables ");
                // Network Information Table (NIT)
                requestTable(false, 0x40, /* TableRequest.TABLE_NAME_NIT */ 3, -1);
                // Service Description Table (SDT)
                requestTable(false, 0x42, /* TableRequest.TABLE_NAME_SDT */ 5, -1);
                // Event Information Table (EIT)
                requestTable(false, 0x4e, /* TableRequest.TABLE_NAME_EIT */ 6, -1);
                return true;
            case KeyEvent.KEYCODE_K:
                updateLogText("Request Video Bounds");
                requestCurrentVideoBoundsWrapper();
                return true;
            case KeyEvent.KEYCODE_L: {
                updateLogText("stop video broadcast with blank mode");
                Bundle params = new Bundle();
                params.putInt(
                        /* TvInteractiveAppService.COMMAND_PARAMETER_KEY_STOP_MODE */
                        "command_stop_mode",
                        /* TvInteractiveAppService.COMMAND_PARAMETER_VALUE_STOP_MODE_BLANK */
                        1);
                tuneChannelByType(TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_STOP,
                        mCurrentTvInputId, null, params);
                return true;
            }
            case KeyEvent.KEYCODE_M: {
                updateLogText("stop video broadcast with freeze mode");
                Bundle params = new Bundle();
                params.putInt(
                        /* TvInteractiveAppService.COMMAND_PARAMETER_KEY_STOP_MODE */
                        "command_stop_mode",
                        /* TvInteractiveAppService.COMMAND_PARAMETER_VALUE_STOP_MODE_FREEZE */
                        2);
                tuneChannelByType(TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_STOP,
                        mCurrentTvInputId, null, params);
                return true;
            }
            case KeyEvent.KEYCODE_N: {
                updateLogText("request AD");
                requestAd();
                return true;
            }
            default:
                return super.onKeyDown(keyCode, event);
        }
    }

    @Override
    public boolean onKeyUp(int keyCode, @NonNull KeyEvent event) {
        switch (keyCode) {
            case KeyEvent.KEYCODE_PROG_RED:
            case KeyEvent.KEYCODE_A:
            case KeyEvent.KEYCODE_B:
            case KeyEvent.KEYCODE_C:
            case KeyEvent.KEYCODE_D:
            case KeyEvent.KEYCODE_E:
            case KeyEvent.KEYCODE_F:
            case KeyEvent.KEYCODE_G:
            case KeyEvent.KEYCODE_H:
            case KeyEvent.KEYCODE_I:
            case KeyEvent.KEYCODE_J:
            case KeyEvent.KEYCODE_K:
            case KeyEvent.KEYCODE_L:
            case KeyEvent.KEYCODE_M:
            case KeyEvent.KEYCODE_N:
                return true;
            default:
                return super.onKeyUp(keyCode, event);
        }
    }

    public void updateLogText(String log) {
        if (DEBUG) {
            Log.d(TAG, log);
        }
        mLogView.setText(log);
    }

    private void updateSurface(Surface surface, int width, int height) {
        mHandler.post(
                () -> {
                    // Update our virtualDisplay if it already exists, create a new one otherwise
                    if (mVirtualDisplay != null) {
                        mVirtualDisplay.setSurface(surface);
                        mVirtualDisplay.resize(width, height, DisplayMetrics.DENSITY_DEFAULT);
                    } else {
                        DisplayManager displayManager =
                                mContext.getSystemService(DisplayManager.class);
                        if (displayManager == null) {
                            Log.e(TAG, "Failed to get DisplayManager");
                            return;
                        }
                        mVirtualDisplay = displayManager.createVirtualDisplay(VIRTUAL_DISPLAY_NAME,
                                        width,
                                        height,
                                        DisplayMetrics.DENSITY_DEFAULT,
                                        surface,
                                        DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY);

                        Presentation presentation =
                                new Presentation(mContext, mVirtualDisplay.getDisplay());
                        presentation.setContentView(mViewContainer);
                        presentation.getWindow().setBackgroundDrawable(new ColorDrawable(0));
                        presentation.show();
                    }
                });
    }

    private void initSampleView() {
        View sampleView = LayoutInflater.from(mContext).inflate(R.layout.sample_layout, null);
        TextView appServiceIdText = sampleView.findViewById(R.id.app_service_id);
        appServiceIdText.setText("App Service ID: " + mAppServiceId);

        mTvInputIdView = sampleView.findViewById(R.id.tv_input_id);
        mChannelUriView = sampleView.findViewById(R.id.channel_uri);
        mVideoTrackView = sampleView.findViewById(R.id.video_track_selected);
        mAudioTrackView = sampleView.findViewById(R.id.audio_track_selected);
        mSubtitleTrackView = sampleView.findViewById(R.id.subtitle_track_selected);
        mLogView = sampleView.findViewById(R.id.log_text);
        // Set default values for the selected tracks, since we cannot request data on them directly
        mVideoTrackView.setText("No video track selected");
        mAudioTrackView.setText("No audio track selected");
        mSubtitleTrackView.setText("No subtitle track selected");

        mVideoView = new VideoView(mContext);
        mVideoView.setVisibility(View.GONE);
        mVideoView.setOnCompletionListener(
                new MediaPlayer.OnCompletionListener() {
                    @Override
                    public void onCompletion(MediaPlayer mediaPlayer) {
                        mVideoView.setVisibility(View.GONE);
                        mLogView.setText("MediaPlayer onCompletion");
                        tuneChannelByType(
                                TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE,
                                mCurrentTvInputId,
                                mCurrentChannelUri);
                    }
                });
        mWidth = 0;
        mHeight = 0;
        WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        mScreenWidth = wm.getDefaultDisplay().getWidth();
        mScreenHeight = wm.getDefaultDisplay().getHeight();

        mViewContainer.addView(sampleView);
    }

    private void updateTrackSelectedView(int type, String trackId) {
        mHandler.post(
                () -> {
                    if (mTracks == null) {
                        return;
                    }
                    TvTrackInfo newSelectedTrack = null;
                    for (TvTrackInfo track : mTracks) {
                        if (track.getType() == type && track.getId().equals(trackId)) {
                            newSelectedTrack = track;
                            break;
                        }
                    }

                    if (newSelectedTrack == null) {
                        if (DEBUG) {
                            Log.d(TAG, "Did not find selected track within track list");
                        }
                        return;
                    }
                    switch (newSelectedTrack.getType()) {
                        case TvTrackInfo.TYPE_VIDEO:
                            mVideoTrackView.setText(
                                    "Video Track: id= " + newSelectedTrack.getId()
                                    + ", height=" + newSelectedTrack.getVideoHeight()
                                    + ", width=" + newSelectedTrack.getVideoWidth()
                                    + ", frame_rate=" + newSelectedTrack.getVideoFrameRate()
                                    + ", pixel_ratio=" + newSelectedTrack.getVideoPixelAspectRatio()
                            );
                            break;
                        case TvTrackInfo.TYPE_AUDIO:
                            mAudioTrackView.setText(
                                    "Audio Track: id=" + newSelectedTrack.getId()
                                    + ", lang=" + newSelectedTrack.getLanguage()
                                    + ", sample_rate=" + newSelectedTrack.getAudioSampleRate()
                                    + ", channel_count=" + newSelectedTrack.getAudioChannelCount()
                            );
                            break;
                        case TvTrackInfo.TYPE_SUBTITLE:
                            mSubtitleTrackView.setText(
                                    "Subtitle Track: id=" + newSelectedTrack.getId()
                                    + ", lang=" + newSelectedTrack.getLanguage()
                            );
                            break;
                    }
                }
        );
    }

    private void tuneChannelByType(String type, String inputId, Uri channelUri, Bundle bundle) {
        Bundle parameters = bundle == null ? new Bundle() : bundle;
        if (TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE.equals(type)) {
            parameters.putString(
                    TvInteractiveAppService.COMMAND_PARAMETER_KEY_CHANNEL_URI,
                    channelUri == null ? null : channelUri.toString());
            parameters.putString(TvInteractiveAppService.COMMAND_PARAMETER_KEY_INPUT_ID, inputId);
        }
        mHandler.post(() -> sendPlaybackCommandRequest(type, parameters));
        // Delay request for new information to give time to tune
        mHandler.postDelayed(
                () -> {
                    requestCurrentTvInputId();
                    requestCurrentChannelUri();
                    requestTrackInfoList();
                },
                1000
        );
    }

    private void tuneChannelByType(String type, String inputId, Uri channelUri) {
        tuneChannelByType(type, inputId, channelUri, new Bundle());
    }

    private void tuneToNextChannel() {
        tuneChannelByType(TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_TUNE_NEXT, null, null);
    }

    @Override
    public void onCurrentChannelUri(Uri channelUri) {
        if (DEBUG) {
            Log.d(TAG, "onCurrentChannelUri uri=" + channelUri);
        }
        mCurrentChannelUri = channelUri;
        mChannelUriView.setText("Channel URI: " + channelUri);
    }

    @Override
    public void onTrackInfoList(List<TvTrackInfo> tracks) {
        if (DEBUG) {
            Log.d(TAG, "onTrackInfoList size=" + tracks.size());
            for (int i = 0; i < tracks.size(); i++) {
                TvTrackInfo trackInfo = tracks.get(i);
                if (trackInfo != null) {
                    Log.d(TAG, "track " + i + ": type=" + trackInfo.getType() +
                            " id=" + trackInfo.getId());
                }
            }
        }
        for (TvTrackInfo info : tracks) {
            if (info.getType() == TvTrackInfo.TYPE_AUDIO) {
                mFirstAudioTrackId = info.getId();
                break;
            }
        }
        mTracks = tracks;
    }

    @Override
    public void onTracksChanged(List<TvTrackInfo> tracks) {
        if (DEBUG) {
            Log.d(TAG, "onTracksChanged");
        }
        onTrackInfoList(tracks);
    }

    @Override
    public void onTrackSelected(int type, String trackId) {
        if (DEBUG) {
            Log.d(TAG, "onTrackSelected type=" + type + " trackId=" + trackId);
        }
        updateTrackSelectedView(type, trackId);

        if (TextUtils.equals(mSelectingAudioTrackId, trackId)) {
            if (mSelectingAudioTrackId == null) {
                updateLogText("unselect audio succeed");
            } else {
                updateLogText("select audio succeed");
            }
        }
    }

    @Override
    public void onCurrentTvInputId(String inputId) {
        if (DEBUG) {
            Log.d(TAG, "onCurrentTvInputId id=" + inputId);
        }
        mCurrentTvInputId = inputId;
        mTvInputIdView.setText("TV Input ID: " + inputId);
    }

    @Override
    public void onTuned(Uri channelUri) {
        mCurrentChannelUri = channelUri;
    }

    @Override
    public void onCurrentVideoBounds(@NonNull Rect bounds) {
        updateLogText("Received video Bounds " + bounds.toShortString());
    }

    @Override
    public void onBroadcastInfoResponse(BroadcastInfoResponse response) {
        if (mGeneratedRequestId == response.getRequestId()) {
            if (!mRequestStreamEventFinished && response instanceof StreamEventResponse) {
                handleStreamEventResponse((StreamEventResponse) response);
            } else if (mSectionReceived < MAX_HANDLED_RESPONSE
                    && response instanceof SectionResponse) {
                handleSectionResponse((SectionResponse) response);
            } else if (response instanceof TableResponse) {
                handleTableResponse((TableResponse) response);
            }
        }
    }

    private void handleSectionResponse(SectionResponse response) {
        mSectionReceived++;
        byte[] data = null;
        Bundle params = response.getSessionData();
        if (params != null) {
            // TODO: define the key
            data = params.getByteArray("key_raw_data");
        }
        int version = response.getVersion();
        updateLogText(
                "Received section data version = "
                        + version
                        + ", data = "
                        + Arrays.toString(data));
    }

    private void handleStreamEventResponse(StreamEventResponse response) {
        updateLogText("Received stream event response");
        byte[] rData = response.getData();
        if (rData == null) {
            mRequestStreamEventFinished = true;
            updateLogText("Received stream event data is null");
            return;
        }
        // TODO: convert to Hex instead
        String data = Arrays.toString(rData);
        if (mStreamDataList.contains(data)) {
            return;
        }
        mStreamDataList.add(data);
        updateLogText(
                "Received stream event data("
                        + (mStreamDataList.size() - 1)
                        + "): "
                        + data);
        if (mStreamDataList.size() >= MAX_HANDLED_RESPONSE) {
            mRequestStreamEventFinished = true;
            updateLogText("Received stream event data finished");
        }
    }

    private void handleTableResponse(TableResponse response) {
        updateLogText(
                "Received table data version = "
                        + response.getVersion()
                        + ", size="
                        + response.getSize()
                        + ", requestId="
                        + response.getRequestId()
                        + ", data = "
                        + Arrays.toString(getTableByteArray(response)));
    }

    private void selectTrack(int type, String trackId) {
        Bundle params = new Bundle();
        params.putInt(TvInteractiveAppService.COMMAND_PARAMETER_KEY_TRACK_TYPE, type);
        params.putString(TvInteractiveAppService.COMMAND_PARAMETER_KEY_TRACK_ID, trackId);
        mHandler.post(
                () ->
                        sendPlaybackCommandRequest(
                                TvInteractiveAppService.PLAYBACK_COMMAND_TYPE_SELECT_TRACK,
                                params));
    }

    private int generateRequestId() {
        return ++mGeneratedRequestId;
    }

    private void requestStreamEvent(String targetUri, String eventName) {
        if (targetUri == null) {
            return;
        }
        int requestId = generateRequestId();
        BroadcastInfoRequest request =
                new StreamEventRequest(
                        requestId,
                        BroadcastInfoRequest.REQUEST_OPTION_AUTO_UPDATE,
                        Uri.parse(targetUri),
                        eventName);
        requestBroadcastInfo(request);
    }

    private void requestSection(boolean repeat, int tsPid, int tableId, int version) {
        int requestId = generateRequestId();
        BroadcastInfoRequest request =
                new SectionRequest(
                        requestId,
                        repeat ?
                                BroadcastInfoRequest.REQUEST_OPTION_REPEAT :
                                BroadcastInfoRequest.REQUEST_OPTION_AUTO_UPDATE,
                        tsPid,
                        tableId,
                        version);
        requestBroadcastInfo(request);
    }

    private void requestTable(boolean repeat,  int tableId, int tableName, int version) {
        int requestId = generateRequestId();
        BroadcastInfoRequest request =
                new TableRequest(
                        requestId,
                        repeat
                                ? BroadcastInfoRequest.REQUEST_OPTION_REPEAT
                                : BroadcastInfoRequest.REQUEST_OPTION_AUTO_UPDATE,
                        tableId,
                        tableName,
                        version);
        requestBroadcastInfo(request);
    }

    public void requestAd() {
        try {
            // TODO: add the AD file to this project
            RandomAccessFile adiFile =
                    new RandomAccessFile(
                            mContext.getApplicationContext().getFilesDir() + "/ad.mp4", "r");
            mAdFd = ParcelFileDescriptor.dup(adiFile.getFD());
        } catch (Exception e) {
            updateLogText("open advertisement file failed. " + e.getMessage());
            return;
        }
        long startTime = 20000;
        long stopTime = startTime + 25000;
        long echoInterval = 1000;
        String mediaFileType = "MP4";
        mHandler.post(
                () -> {
                    AdRequest adRequest;
                    if (mAdState == AdResponse.RESPONSE_TYPE_PLAYING) {
                        updateLogText("RequestAd stop");
                        adRequest =
                                new AdRequest(
                                        mGeneratedRequestId,
                                        AdRequest.REQUEST_TYPE_STOP,
                                        null,
                                        0,
                                        0,
                                        0,
                                        null,
                                        null);
                    } else {
                        updateLogText("RequestAd start");
                        int requestId = generateRequestId();
                        mAdSurfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
                        mAdSurfaceView.setVisibility(View.VISIBLE);
                        Bundle bundle = new Bundle();
                        bundle.putParcelable("dai_surface", mAdSurface);
                        adRequest =
                                new AdRequest(
                                        requestId,
                                        AdRequest.REQUEST_TYPE_START,
                                        mAdFd,
                                        startTime,
                                        stopTime,
                                        echoInterval,
                                        mediaFileType,
                                        bundle);
                    }
                    requestAd(adRequest);
                });
    }

    @TargetApi(34)
    private List<AppLinkInfo> getAppLinkInfoList() {
        if (Build.VERSION.SDK_INT < 34 || mTvIAppManager == null) {
            return new ArrayList<>();
        }
        return mTvIAppManager.getAppLinkInfoList();
    }

    @TargetApi(34)
    private void requestCurrentVideoBoundsWrapper() {
        if (Build.VERSION.SDK_INT < 34) {
            return;
        }
        requestCurrentVideoBounds();
    }

    @TargetApi(34)
    private byte[] getTableByteArray(TableResponse response) {
        if (Build.VERSION.SDK_INT < 34) {
            return null;
        }
        return response.getTableByteArray();
    }
}