4715 lines
196 KiB
Java
4715 lines
196 KiB
Java
package kr.co.rito.osicmanager;
|
|
|
|
import androidx.annotation.OptIn;
|
|
import androidx.appcompat.app.AppCompatActivity;
|
|
import androidx.appcompat.widget.AppCompatTextView;
|
|
|
|
import android.app.Activity;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.res.AssetFileDescriptor;
|
|
import android.content.res.AssetManager;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Paint;
|
|
import android.graphics.PixelFormat;
|
|
import android.graphics.Point;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.Rect;
|
|
import android.graphics.SurfaceTexture;
|
|
import android.graphics.drawable.BitmapDrawable;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.text.LineBreaker;
|
|
import android.media.AudioAttributes;
|
|
import android.media.AudioFormat;
|
|
import android.media.AudioManager;
|
|
import android.media.AudioTrack;
|
|
import android.media.MediaPlayer;
|
|
import android.media.SoundPool;
|
|
import android.net.Uri;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Environment;
|
|
import android.os.FileUtils;
|
|
import android.os.SystemClock;
|
|
import android.provider.MediaStore;
|
|
import android.text.Layout;
|
|
import android.text.StaticLayout;
|
|
import android.text.TextPaint;
|
|
import android.util.JsonReader;
|
|
import android.util.Log;
|
|
import android.view.Display;
|
|
import android.view.Gravity;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.SurfaceHolder;
|
|
import android.view.SurfaceView;
|
|
import android.view.TextureView;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.webkit.JavascriptInterface;
|
|
import android.webkit.WebResourceError;
|
|
import android.webkit.WebResourceRequest;
|
|
import android.webkit.WebResourceResponse;
|
|
import android.webkit.WebView;
|
|
import android.webkit.WebViewClient;
|
|
import android.widget.FrameLayout;
|
|
import android.widget.ImageView;
|
|
import android.widget.ProgressBar;
|
|
import android.widget.RelativeLayout;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import com.google.android.exoplayer2.ExoPlayer;
|
|
import com.google.android.exoplayer2.MediaItem;
|
|
import com.google.android.exoplayer2.PlaybackException;
|
|
import com.google.android.exoplayer2.Player;
|
|
import com.google.android.exoplayer2.Timeline;
|
|
import com.google.android.exoplayer2.source.MediaSource;
|
|
import com.google.android.exoplayer2.source.ProgressiveMediaSource;
|
|
import com.google.android.exoplayer2.source.hls.HlsManifest;
|
|
import com.google.android.exoplayer2.upstream.AssetDataSource;
|
|
import com.google.android.exoplayer2.upstream.DataSource;
|
|
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.RandomAccessFile;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.lang.ref.WeakReference;
|
|
import java.lang.reflect.Method;
|
|
import java.net.URLDecoder;
|
|
import java.nio.charset.Charset;
|
|
import java.security.SecureRandom;
|
|
import java.security.cert.CertificateException;
|
|
import java.security.cert.X509Certificate;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Queue;
|
|
import java.util.Random;
|
|
import java.util.concurrent.LinkedBlockingQueue;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
//import com.downloader.Error;
|
|
//import com.downloader.OnCancelListener;
|
|
//import com.downloader.OnDownloadListener;
|
|
//import com.downloader.OnPauseListener;
|
|
//import com.downloader.OnProgressListener;
|
|
//import com.downloader.OnStartOrResumeListener;
|
|
//import com.downloader.PRDownloader;
|
|
//import com.downloader.PRDownloaderConfig;
|
|
//import com.downloader.Progress;
|
|
|
|
import javax.net.ssl.HostnameVerifier;
|
|
import javax.net.ssl.SSLContext;
|
|
import javax.net.ssl.SSLSession;
|
|
import javax.net.ssl.TrustManager;
|
|
import javax.net.ssl.X509TrustManager;
|
|
|
|
import kr.co.rito.ritoplayer.RitoPlayer;
|
|
import okhttp3.Call;
|
|
import okhttp3.Callback;
|
|
import okhttp3.OkHttpClient;
|
|
import okhttp3.Request;
|
|
import okhttp3.Response;
|
|
|
|
import org.eclipse.paho.android.service.MqttAndroidClient;
|
|
import org.eclipse.paho.client.mqttv3.IMqttActionListener;
|
|
import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
|
|
import org.eclipse.paho.client.mqttv3.IMqttMessageListener;
|
|
import org.eclipse.paho.client.mqttv3.IMqttToken;
|
|
import org.eclipse.paho.client.mqttv3.MqttCallback;
|
|
import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
|
|
import org.eclipse.paho.client.mqttv3.MqttException;
|
|
import org.eclipse.paho.client.mqttv3.MqttMessage;
|
|
import org.json.JSONArray;
|
|
import org.json.JSONObject;
|
|
import org.videolan.libvlc.interfaces.IMedia;
|
|
import org.videolan.libvlc.interfaces.IVLCVout;
|
|
import org.videolan.libvlc.LibVLC;
|
|
import org.videolan.libvlc.Media;
|
|
//import org.videolan.libvlc.MediaPlayer;
|
|
|
|
public class MainActivity extends AppCompatActivity implements IVLCVout.Callback, TextureView.SurfaceTextureListener {
|
|
public final static String TAG = "OsicMain";
|
|
public static int PLAYER_LIBRARY_TYPE_RITO = 1;
|
|
public static int PLAYER_LIBRARY_TYPE_VLC = 2;
|
|
public static int USING_MAIN_PLAYER_LIBRARY_TYPE = PLAYER_LIBRARY_TYPE_VLC;
|
|
//public static int USING_MAIN_PLAYER_LIBRARY_TYPE = PLAYER_LIBRARY_TYPE_RITO;
|
|
|
|
public static int PLAYER_VIEW_TYPE_SURFACE_VIEW = 1;
|
|
public static int PLAYER_VIEW_TYPE_TEXTURE_VIEW = 2;
|
|
public static int USING_PLAYER_VIEW_TYPE = PLAYER_VIEW_TYPE_TEXTURE_VIEW;
|
|
|
|
static int MANAGER_NOTIFY_ORDER_START_PLAYBACK = 1;
|
|
static int MANAGER_NOTIFY_ORDER_STOP_PLAYBACK = 2;
|
|
static int MANAGER_NOTIFY_ORDER_START_TICKER = 3;
|
|
static int MANAGER_NOTIFY_ORDER_START_TTS = 4;
|
|
static int MANAGER_NOTIFY_ORDER_CEC_CONTROL = 5;
|
|
static int MANAGER_NOTIFY_ORDER_JSON_ORDER = 6;
|
|
static int MANAGER_NOTIFY_ORDER_NOTIFY_SCREEN_ORDER = 7;
|
|
static int MANAGER_NOTIFY_ORDER_EVENT_MESSAGE = 8;
|
|
|
|
static String MANAGER_JSON_ORDER_TYPE_PLAY_CONTENTS = "filecast";
|
|
static String MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST = "ipcast";
|
|
static String MANAGER_JSON_ORDER_TYPE_PLAY_CARCAST = "carcast";
|
|
|
|
static String MANAGER_ACTION_MODE_STANDBY = "standby";
|
|
static String MANAGER_ACTION_MODE_SERVICE = "inservice";
|
|
|
|
static int VLC_NETWORK_CACHE_DEFAULT = 1500;
|
|
static int VLC_LIVE_CACHE_DEFAULT = 1500;
|
|
static int VLC_UDP_BUFFER_DEFAULT = 32768;
|
|
|
|
private long mKeyPressTime;
|
|
private long mNotifyMsgStartTime;
|
|
public boolean mIsOnNotifyMsg;
|
|
public boolean mIsOnTTSPlaying;
|
|
public boolean mIsDeviceOSIC10;
|
|
private int mLastSpeakerVolume;
|
|
private int mLastDacVolume;
|
|
private int mLastVideoVolume;
|
|
|
|
private SurfaceView mSurface;
|
|
private TextureView mTexturePlayView;
|
|
private SurfaceHolder holder;
|
|
private LibVLC mVLC;
|
|
private String mCurrentPlayUrl;
|
|
private String mLastPlayUrl;
|
|
private String mShouldPlayUrl;
|
|
private boolean mShouldStopPlay = false;
|
|
org.videolan.libvlc.MediaPlayer mVlcPlayer;
|
|
private Media mVLCMedia;
|
|
private int mVlcVolume;
|
|
private int mVlcMaxVolume;
|
|
|
|
ImageView mChannelOsdImageView;
|
|
ImageView mImageViewBlack;
|
|
TextView mChannelOsdView;
|
|
ProgressBar mProgressBar;
|
|
|
|
TextView mCarCastTitleView;
|
|
|
|
private String mManagerActMode;
|
|
public String mWardId; // for 119
|
|
public String mDsrSeq; // for 119
|
|
public String mCastReceivedNotifyDsrSeq; // for 119
|
|
public long mDsrCastReceivedTime; // for 119
|
|
public String mEbcastMqttIp; // for 119
|
|
public static final int EBCAST_SAMPLE_RATE = 16000; // 샘플링 레이트 (Hz)
|
|
public static final int EBCAST_CHANNEL_CONFIG = AudioFormat.CHANNEL_OUT_MONO; // 모노
|
|
public static final int EBCAST_AUDIO_FORMAT = AudioFormat.ENCODING_PCM_16BIT; // 16비트 PCM
|
|
public AudioTrack mAudioTrack;
|
|
public ExoPlayer mExoPlayer = null;
|
|
|
|
|
|
boolean mIsRitoPlayerOver;
|
|
RitoPlayer mPlayer;
|
|
RitoPlayer mAudioPlayer;
|
|
RitoPlayer.playerNotify mPlayerNotify;
|
|
RitoPlayer.AudioOut mAudioSubOut;
|
|
AudioFilePlayer mTTSPlayer;
|
|
TickerManager mTickerManager;
|
|
VfdManager mVfdManager;
|
|
SystemManager mSystemManager;
|
|
CoolerManager mCoolerManager;
|
|
FileDownloader mFileDownloader;
|
|
public static MainActivity INSTANCE;
|
|
|
|
public String mSDCardPath;
|
|
public String mSDSavePath;
|
|
public String mEmmcSavePath;
|
|
public JsonResult mJsonResult;
|
|
public JsonResult mJsonIpSchedule;
|
|
public JsonResult mJsonFileSchedule;
|
|
public JsonScheduler mJsonScheduler;
|
|
public DacScheduler mDacScheduler;
|
|
|
|
private static SoundPool mSoundPool;
|
|
private static HashMap<Integer, Integer> mSoundPoolMap;
|
|
|
|
public static MqttAndroidClient mqttAndroidClient = null;
|
|
|
|
// Used to load the 'osic-lib' library on application startup.
|
|
static {
|
|
System.loadLibrary("osic-lib");
|
|
}
|
|
|
|
private static void shellCommand(String order) {
|
|
try {
|
|
Process process = Runtime.getRuntime().exec(order);
|
|
process.waitFor();
|
|
process.destroy();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private static void shellCommand(String[] order) {
|
|
try {
|
|
Process process = Runtime.getRuntime().exec(order);
|
|
process.waitFor();
|
|
process.destroy();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSurfacesCreated(IVLCVout ivlcVout) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSurfacesDestroyed(IVLCVout ivlcVout) {
|
|
|
|
}
|
|
|
|
@Override
|
|
public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int i, int i1) {
|
|
Log.w(TAG, "Surfacee Texture Created!!");
|
|
//createPlayer("http://219.255.217.140/ext/contents/Your_wedding.ts");
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
createPlayer(null);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int i, int i1) {
|
|
// final IVLCVout vout = mVlcPlayer.getVLCVout();
|
|
// vout.detachViews();
|
|
// vout.setVideoView(mTexturePlayView);
|
|
// vout.attachViews();
|
|
// mVlcPlayer.updateVideoSurfaces();
|
|
}
|
|
|
|
@Override
|
|
public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
|
|
|
|
}
|
|
|
|
|
|
|
|
class CoolerManager extends Thread {
|
|
public int CPU_FAN_GPIO_NUMBER = 156;
|
|
public boolean mIsAlive = false;
|
|
|
|
public void terminate() {
|
|
mIsAlive = false;
|
|
}
|
|
|
|
public void initialize() {
|
|
SystemUtil.pinSetup(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_OUT);
|
|
}
|
|
|
|
public void activateCpuFan(boolean activate) {
|
|
if(activate) {
|
|
SystemUtil.setPinValue(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_HIGH);
|
|
} else {
|
|
SystemUtil.setPinValue(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_LOW);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
mIsAlive = true;
|
|
while(mIsAlive) {
|
|
activateCpuFan(true);
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
activateCpuFan(false);
|
|
try {
|
|
sleep(300);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setSpeakerVolume(int volume) {
|
|
try {
|
|
int volumeInt = volume;
|
|
if(mLastSpeakerVolume != volumeInt) {
|
|
mLastSpeakerVolume = volumeInt;
|
|
|
|
String order = String.format("ritoi2c w /dev/i2c-6 0x31 0x13 0x%X", (100 - mLastSpeakerVolume));
|
|
shellCommand(order);
|
|
}
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
public void setVideoVolume(int volume) {
|
|
try {
|
|
int volumeInt = volume;
|
|
if(mLastVideoVolume != volumeInt) {
|
|
mLastVideoVolume = volumeInt;
|
|
|
|
String order = String.format("ritosysc SHELL-ORDER=media volume --show --stream 3 --set %d", mLastVideoVolume);
|
|
shellCommand(order);
|
|
}
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
public void setDacVolume(int volume) {
|
|
try {
|
|
int volumeInt = volume;
|
|
if(mLastDacVolume != volumeInt) {
|
|
mLastDacVolume = volumeInt;
|
|
|
|
}
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
class SystemManager extends Thread {
|
|
public int CPU_FAN_GPIO_NUMBER = 156;
|
|
public boolean mIsAlive = false;
|
|
|
|
public void terminate() {
|
|
mIsAlive = false;
|
|
}
|
|
|
|
public void initialize() {
|
|
SystemUtil.pinSetup(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_OUT);
|
|
}
|
|
|
|
public void activateCpuFan(boolean activate) {
|
|
if(activate) {
|
|
SystemUtil.setPinValue(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_HIGH);
|
|
} else {
|
|
SystemUtil.setPinValue(CPU_FAN_GPIO_NUMBER, SystemUtil.GPIO_LOW);
|
|
}
|
|
}
|
|
|
|
public void stopNotifyScreen() {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
findViewById(R.id.surfaceViewCmd).setVisibility(View.INVISIBLE);
|
|
findViewById(R.id.layoutCommand).setVisibility(View.INVISIBLE);
|
|
// findViewById(R.id.surfaceViewCmd).setAlpha(0.0f);
|
|
// findViewById(R.id.layoutCommand).setAlpha(0.0f);
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mVlcPlayer != null) {
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
Log.w(TAG, "**********************");
|
|
Log.w(TAG, " 지령화면 표시종료 ");
|
|
Log.w(TAG, "**********************");
|
|
|
|
shellCommand("miscctrl function_led red off");
|
|
shellCommand("miscctrl function_led green off");
|
|
shellCommand("miscctrl function_led blue off");
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
int aliveCount = 0;
|
|
int mSpkVolumeCheckCount = 20;
|
|
mIsAlive = true;
|
|
while(mIsAlive) {
|
|
long curTime = SystemClock.uptimeMillis();
|
|
if(BuildConfig.SPECIAL_APP_MODE.equals("119NOTI_DEMO")) {
|
|
curTime = mNotifyMsgStartTime;
|
|
}
|
|
|
|
if(mNotifyMsgStartTime > 0) {
|
|
if(curTime - mNotifyMsgStartTime > 60 * 1000) { // 30 * 1000 -> 60 * 1000 by ritoseo - 2021.04.08
|
|
mNotifyMsgStartTime = 0;
|
|
mIsOnNotifyMsg = false;
|
|
stopNotifyScreen();
|
|
}
|
|
}
|
|
|
|
mSpkVolumeCheckCount++;
|
|
if(mSpkVolumeCheckCount >= 10) {
|
|
mSpkVolumeCheckCount = 0;
|
|
String volume = SystemUtil.getConfigValue("spkvolume");
|
|
if(volume.length() == 0) {
|
|
volume = "100";
|
|
}
|
|
|
|
try {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
setSpeakerVolume(volumeInt);
|
|
} catch(Exception e) {
|
|
}
|
|
|
|
volume = SystemUtil.getConfigValue("videovolume");
|
|
if(volume.length() == 0) {
|
|
volume = "12";
|
|
}
|
|
|
|
try {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
setVideoVolume(volumeInt);
|
|
} catch(Exception e) {
|
|
}
|
|
|
|
|
|
volume = SystemUtil.getConfigValue("dacvolume");
|
|
if(volume.length() == 0) {
|
|
volume = "100";
|
|
}
|
|
|
|
//Log.d("RITO", "dacvolume : " + volume);
|
|
try {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
setDacVolume(volumeInt);
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
if(!SystemUtil.property_get("sys.rito.freeze").equals("liveness")) {
|
|
aliveCount++;
|
|
aliveCount %= 10000000;
|
|
SystemUtil.property_set("sys.rito.osic.liveness", "" + aliveCount);
|
|
}
|
|
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class VfdManager extends Thread {
|
|
public int VFD_TOTAL_WIDTH = 16;
|
|
public int VFD_TOTAL_HEIGHT = 2;
|
|
public int VFD_ALIGN_LEFT = 1;
|
|
public int VFD_ALIGN_CENTER = 2;
|
|
public int VFD_ALIGN_RIGHT = 3;
|
|
private long mChangedTime = 0;
|
|
|
|
private Object mLock = new Object();
|
|
private int mSetIdx = -1;
|
|
private int mChangeSection = 0;
|
|
public String[] mSettingOrder = { "STATION IP", "STATION NM", "STATION GW", "STATION DNS", "SERVER IP", "SERVER PORT" };
|
|
|
|
public boolean mVfdChangeMode = false;
|
|
public boolean mVfdConfirmMode = false; // added by ritoseo - 2023-03-21
|
|
public boolean mVfdConfirmYesNo = false; // added by ritoseo - 2023-03-21
|
|
private int mVfdChangeType = 0;
|
|
private String mVfdChangingValue = "";
|
|
|
|
private String mVfdBaseString = "";
|
|
|
|
private boolean isTitleIpType(String title) {
|
|
if(title.equals("STATION IP") ||
|
|
title.equals("STATION NM") ||
|
|
title.equals("STATION GW") ||
|
|
title.equals("STATION DNS") ||
|
|
title.equals("SERVER IP")) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private String currentTitleString() {
|
|
int idx;
|
|
synchronized (mLock) {
|
|
idx = mSetIdx;
|
|
}
|
|
if(idx < 0)
|
|
return "OSIC-10";
|
|
|
|
return mSettingOrder[idx];
|
|
}
|
|
|
|
public void cancelVfdChangeMode() {
|
|
if(mSetIdx < 0)
|
|
return;
|
|
|
|
if(mVfdChangeMode) {
|
|
moveCursor(0, 0, 0);
|
|
mChangedTime = SystemClock.uptimeMillis();
|
|
mVfdChangeMode = false;
|
|
}
|
|
}
|
|
|
|
public void toggleVfdChangeMode() {
|
|
//Log.w(TAG, "VfdChangeMode : " + mVfdChangeMode);
|
|
if(mSetIdx < 0)
|
|
return;
|
|
|
|
if(mVfdChangeMode) {
|
|
moveCursor(0, 0, 0);
|
|
/* Added by ritoseo - 2023-03-21 */
|
|
// if(!mVfdConfirmMode && confirmSettingCheck()) {
|
|
// mVfdConfirmMode = true;
|
|
// mVfdConfirmYesNo = true;
|
|
// vfdDrawString("SAVE CHANGES?", 0, VFD_ALIGN_CENTER);
|
|
// toggleConfirmValue();
|
|
// return;
|
|
// }
|
|
/* ------------------------------ */
|
|
confirmSettingValue();
|
|
mVfdChangeMode = false;
|
|
} else {
|
|
mVfdChangeMode = true;
|
|
String curTitle = currentTitleString();
|
|
|
|
if(isTitleIpType(curTitle)) {
|
|
if(mVfdChangingValue.length() == 0)
|
|
mVfdChangingValue = "0.0.0.0";
|
|
|
|
vfdDrawString(mVfdChangingValue, 1, VFD_ALIGN_CENTER);
|
|
String padString = makePaddingString(mVfdChangingValue);
|
|
int pos = padString.indexOf('.');
|
|
if(pos > 0) {
|
|
mChangeSection = 0;
|
|
moveCursor(pos - 1, 1, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private String changeSectionValue(String valueString, int section, int direction) {
|
|
String result;
|
|
String[] splitValue = valueString.split("\\.");
|
|
|
|
Log.w(TAG, "splitValue Length : " + splitValue.length + ", valueString : " + valueString);
|
|
if(splitValue.length < 4)
|
|
return valueString;
|
|
|
|
int value = Integer.parseInt(splitValue[section]);
|
|
value += direction;
|
|
if(value < 0)
|
|
value = 255;
|
|
value %= 256;
|
|
|
|
splitValue[section] = "" + value;
|
|
|
|
result = String.format("%s.%s.%s.%s", splitValue[0], splitValue[1], splitValue[2], splitValue[3]);
|
|
return result;
|
|
}
|
|
|
|
private int getCursorOfSection(String valueString, int section) {
|
|
if(section == 3) {
|
|
for(int i = valueString.length() - 1;i >= 0;i--) {
|
|
if(valueString.charAt(i) >= '0' && valueString.charAt(i) <= '9')
|
|
return i;
|
|
}
|
|
|
|
return valueString.length() - 1;
|
|
}
|
|
|
|
int cnt = -1;
|
|
for(int i = 0;i < valueString.length();i++) {
|
|
if(valueString.charAt(i) == '.') {
|
|
cnt++;
|
|
if(cnt == section) {
|
|
return i - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void applyNetworkSettings() {
|
|
String ipaddr = getConfigValue("ipaddr");
|
|
String netmask = getConfigValue("netmask");
|
|
String gateway = getConfigValue("gateway");
|
|
String dns = getConfigValue("dns");
|
|
|
|
Log.w(TAG, String.format("[applyNetwork] %s, %s, %s, %s", ipaddr, netmask, gateway, dns));
|
|
if(ipaddr.length() > 0 && netmask.length() > 0 && gateway.length() > 0 && dns.length() > 0) {
|
|
shellCommand("setConfig iptype static");
|
|
}
|
|
}
|
|
|
|
public boolean confirmSettingCheck() {
|
|
String title = currentTitleString();
|
|
boolean needConfirm = false;
|
|
|
|
if(title.equals("STATION IP")) {
|
|
needConfirm = true;
|
|
} else if(title.equals("STATION NM")) {
|
|
needConfirm = true;
|
|
} else if(title.equals("STATION GW")) {
|
|
needConfirm = true;
|
|
} else if(title.equals("STATION DNS")) {
|
|
needConfirm = true;
|
|
} else if(title.equals("SERVER IP")) {
|
|
needConfirm = true;
|
|
}
|
|
|
|
return needConfirm;
|
|
}
|
|
|
|
private void drawSaveVfd() {
|
|
vfdDrawString("SAVE", 0, VFD_ALIGN_CENTER);
|
|
vfdDrawString("", 1, VFD_ALIGN_CENTER);
|
|
}
|
|
|
|
public void confirmSettingValue() {
|
|
String title = currentTitleString();
|
|
|
|
if(title.equals("STATION IP")) {
|
|
drawSaveVfd();
|
|
shellCommand("setConfig ipaddr " + mVfdChangingValue);
|
|
applyNetworkSettings();
|
|
} else if(title.equals("STATION NM")) {
|
|
drawSaveVfd();
|
|
shellCommand("setConfig netmask " + mVfdChangingValue);
|
|
applyNetworkSettings();
|
|
} else if(title.equals("STATION GW")) {
|
|
drawSaveVfd();
|
|
shellCommand("setConfig gateway " + mVfdChangingValue);
|
|
applyNetworkSettings();
|
|
} else if(title.equals("STATION DNS")) {
|
|
drawSaveVfd();
|
|
shellCommand("setConfig dns " + mVfdChangingValue);
|
|
applyNetworkSettings();
|
|
} else if(title.equals("SERVER IP")) {
|
|
drawSaveVfd();
|
|
shellCommand("setConfig svraddr " + mVfdChangingValue);
|
|
}
|
|
}
|
|
|
|
private void toggleConfirmValue() {
|
|
mVfdConfirmYesNo = !mVfdConfirmYesNo;
|
|
if(mVfdConfirmMode) {
|
|
vfdDrawString("YES", 1, VFD_ALIGN_CENTER);
|
|
} else {
|
|
vfdDrawString("NO", 1, VFD_ALIGN_CENTER);
|
|
}
|
|
}
|
|
|
|
public void changeSettingValue(int direction) {
|
|
// if(mVfdConfirmMode) {
|
|
// toggleConfirmValue();
|
|
// return;
|
|
// }
|
|
|
|
if(mVfdChangeMode) {
|
|
mVfdChangingValue = changeSectionValue(mVfdChangingValue, mChangeSection, direction);
|
|
vfdDrawString(mVfdChangingValue, 1, VFD_ALIGN_CENTER);
|
|
|
|
String padString = makePaddingString(mVfdChangingValue);
|
|
int pos = getCursorOfSection(padString, mChangeSection);
|
|
moveCursor(pos, 1, 1);
|
|
}
|
|
}
|
|
|
|
public void moveSettingMode(int direction) {
|
|
int idx;
|
|
// if(mVfdConfirmMode) {
|
|
// return;
|
|
// }
|
|
|
|
if(mVfdChangeMode) {
|
|
String curTitle = currentTitleString();
|
|
|
|
if(isTitleIpType(curTitle)) {
|
|
//String[] valueDigit = mVfdChangingValue.split(".");
|
|
mChangeSection += direction;
|
|
if(mChangeSection < 0)
|
|
mChangeSection = 3;
|
|
mChangeSection %= 4;
|
|
|
|
String padString = makePaddingString(mVfdChangingValue);
|
|
int pos = getCursorOfSection(padString, mChangeSection);
|
|
moveCursor(pos, 1, 1);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
synchronized (mLock) {
|
|
mSetIdx += direction;
|
|
if (mSetIdx < 0)
|
|
mSetIdx = mSettingOrder.length - 1;
|
|
mSetIdx %= mSettingOrder.length;
|
|
idx = mSetIdx;
|
|
}
|
|
printModeTitle(idx);
|
|
printModeValue(idx);
|
|
mChangedTime = SystemClock.uptimeMillis();
|
|
}
|
|
|
|
private void setSettingMode(int index) {
|
|
synchronized (mLock) {
|
|
mSetIdx = index;
|
|
}
|
|
|
|
printModeTitle(index);
|
|
printModeValue(index);
|
|
mChangedTime = SystemClock.uptimeMillis();
|
|
}
|
|
|
|
private void printModeTitle(int mode) {
|
|
if(mode < 0) { // clear
|
|
vfdDrawString("OSIC-10", 0, VFD_ALIGN_CENTER);
|
|
return;
|
|
}
|
|
vfdDrawString(mSettingOrder[mode], 0, VFD_ALIGN_CENTER);
|
|
}
|
|
|
|
private void moveCursor(int x, int y, int mode) {
|
|
String[] order = {"vfdctrl", "cursorxy", "" + x, "" + y};
|
|
shellCommand(order);
|
|
if(mode == 0) {
|
|
shellCommand("vfdctrl showcursor off");
|
|
} else {
|
|
shellCommand("vfdctrl showcursor on");
|
|
}
|
|
}
|
|
|
|
private boolean isIptypeStatic() {
|
|
String iptype = getConfigValue("ipv4type");
|
|
if(iptype.equals("static"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private void printModeValue(int mode) {
|
|
String value = "";
|
|
if(mode < 0) { // clear
|
|
vfdDrawString("", 1, VFD_ALIGN_CENTER);
|
|
return;
|
|
}
|
|
if(mSettingOrder[mode].equals("STATION IP")) {
|
|
value = getIPAddress();
|
|
if(isIptypeStatic()) {
|
|
String temp = getConfigValue("ipaddr");
|
|
if(temp.length() > 0)
|
|
value = temp;
|
|
}
|
|
} else if(mSettingOrder[mode].equals("STATION NM")) {
|
|
value = getNetmask();
|
|
if(isIptypeStatic()) {
|
|
String temp = getConfigValue("netmask");
|
|
if(temp.length() > 0)
|
|
value = temp;
|
|
}
|
|
} else if(mSettingOrder[mode].equals("STATION GW")) {
|
|
value = getGateway();
|
|
if(isIptypeStatic()) {
|
|
String temp = getConfigValue("gateway");
|
|
if(temp.length() > 0)
|
|
value = temp;
|
|
}
|
|
} else if(mSettingOrder[mode].equals("STATION DNS")) {
|
|
value = SystemUtil.property_get("net.dns1");
|
|
if(isIptypeStatic()) {
|
|
String temp = getConfigValue("dns");
|
|
if(temp.length() > 0)
|
|
value = temp;
|
|
}
|
|
} else if(mSettingOrder[mode].equals("SERVER IP")) {
|
|
value = getServerAddress();
|
|
} else if(mSettingOrder[mode].equals("SERVER PORT")) {
|
|
value = "" + getServerPort();
|
|
}
|
|
|
|
Log.w(TAG, "VALUE : " + value);
|
|
mVfdChangingValue = value;
|
|
vfdDrawString(value, 1, VFD_ALIGN_CENTER);
|
|
}
|
|
|
|
String makePaddingString(String string) {
|
|
int x;
|
|
int length;
|
|
String strMessage = "";
|
|
String strLeftPadding = "";
|
|
String strRightPadding = "";
|
|
length = string.length();
|
|
x = (VFD_TOTAL_WIDTH - length) / 2;
|
|
if(x > 0) {
|
|
for(int i = 0; i < x;i++)
|
|
strLeftPadding += " ";
|
|
}
|
|
if(VFD_TOTAL_WIDTH - length - x > 0) {
|
|
for(int i = 0; i < VFD_TOTAL_WIDTH - length - x;i++)
|
|
strRightPadding += " ";
|
|
}
|
|
strMessage = strLeftPadding + string + strRightPadding;
|
|
|
|
return strMessage;
|
|
}
|
|
|
|
void vfdDrawString(String string, int y, int flag)
|
|
{
|
|
int x;
|
|
int length;
|
|
String strMessage = "";
|
|
String strLeftPadding = "";
|
|
String strRightPadding = "";
|
|
|
|
length = string.length();
|
|
|
|
if(flag == VFD_ALIGN_LEFT) {
|
|
x = 0;
|
|
|
|
if(VFD_TOTAL_WIDTH - length > 0) {
|
|
for(int i = 0; i < VFD_TOTAL_WIDTH - length;i++)
|
|
strRightPadding += ' ';
|
|
}
|
|
} else if(flag == VFD_ALIGN_CENTER) {
|
|
x = (VFD_TOTAL_WIDTH - length) / 2;
|
|
if(x > 0) {
|
|
for(int i = 0; i < x;i++)
|
|
strLeftPadding += " ";
|
|
}
|
|
if(VFD_TOTAL_WIDTH - length - x > 0) {
|
|
for(int i = 0; i < VFD_TOTAL_WIDTH - length - x;i++)
|
|
strRightPadding += " ";
|
|
}
|
|
} else {
|
|
x = VFD_TOTAL_WIDTH - length;
|
|
}
|
|
|
|
strMessage = strLeftPadding + string + strRightPadding;
|
|
printVfdMessage(0, y, strMessage);
|
|
}
|
|
|
|
public void printVfdMessage(int x, int y, String msg) {
|
|
/*Log.w(TAG, String.format("%d, %d, MSG : %s", x, y, msg));*/
|
|
/*String order = String.format("vfdctrl printxy %d %d %s", x, y, msg);
|
|
try {
|
|
String newOrder = new String(order.getBytes("US-ASCII"), "US-ASCII");
|
|
Log.w(TAG, "new order : " + newOrder);
|
|
shellCommand(newOrder.trim());
|
|
} catch (UnsupportedEncodingException e) {
|
|
e.printStackTrace();
|
|
}*/
|
|
|
|
String[] order = {"vfdctrl", "printxy", "" + x, "" + y, msg};
|
|
shellCommand(order);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void run() {
|
|
while(true) {
|
|
long curTime = SystemClock.uptimeMillis();
|
|
|
|
if(curTime - mChangedTime >= 7 * 1000) {
|
|
if(!mVfdChangeMode) {
|
|
setSettingMode(-1);
|
|
}
|
|
}
|
|
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class AudioFilePlayer extends Thread {
|
|
int DOWNLOAD_STATUS_PROCESS = 0;
|
|
int DOWNLOAD_STATUS_SUCCESS = 1;
|
|
int DOWNLOAD_STATUS_FAILED = 2;
|
|
private boolean mChimeUpDone = false;
|
|
private boolean mChimeDownDone = false;
|
|
private int mProgress = 0;
|
|
private int mLastProgress = 0;
|
|
private int mPlayVolume = 100;
|
|
private int mDownloadStatus = DOWNLOAD_STATUS_PROCESS;
|
|
private String mTTSPath;
|
|
private boolean mIsAlive = false;
|
|
private String mPlayMode;
|
|
private String mPlayTarget;
|
|
//MediaPlayer mMediaPlayer; // deprecated by ritoseo - 2024-12-16
|
|
ExoPlayer mExoPlayer;
|
|
|
|
private class CallbackToDownloadFile implements Callback {
|
|
|
|
private File directory;
|
|
private File fileToBeDownloaded;
|
|
|
|
public CallbackToDownloadFile(String directory, String fileName) {
|
|
this.directory = new File(directory);
|
|
this.fileToBeDownloaded = new File(this.directory.getAbsolutePath() + "/" + fileName);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void onFailure(Call call, IOException e) {
|
|
mDownloadStatus = DOWNLOAD_STATUS_FAILED;
|
|
/*runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Toast.makeText(
|
|
MainActivity.this,
|
|
"파일을 다운로드할 수 없습니다. 인터넷 연결을 확인하세요.",
|
|
Toast.LENGTH_SHORT
|
|
).show();
|
|
}
|
|
});*/
|
|
}
|
|
|
|
@Override
|
|
public void onResponse(Call call, Response response) throws IOException {
|
|
if(!response.isSuccessful()) {
|
|
mDownloadStatus = DOWNLOAD_STATUS_FAILED;
|
|
return;
|
|
}
|
|
|
|
if (!this.directory.exists()) {
|
|
this.directory.mkdirs();
|
|
}
|
|
|
|
if (this.fileToBeDownloaded.exists()) {
|
|
this.fileToBeDownloaded.delete();
|
|
}
|
|
|
|
try {
|
|
this.fileToBeDownloaded.createNewFile();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
/*runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Toast.makeText(
|
|
MainActivity.this,
|
|
"다운로드 파일을 생성할 수 없습니다.",
|
|
Toast.LENGTH_SHORT
|
|
).show();
|
|
}
|
|
});*/
|
|
|
|
mDownloadStatus = DOWNLOAD_STATUS_FAILED;
|
|
return;
|
|
}
|
|
|
|
InputStream is = response.body().byteStream();
|
|
OutputStream os = new FileOutputStream(this.fileToBeDownloaded);
|
|
|
|
final int BUFFER_SIZE = 2048;
|
|
byte[] data = new byte[BUFFER_SIZE];
|
|
|
|
int count;
|
|
long total = 0;
|
|
|
|
while ((count = is.read(data)) != -1) {
|
|
total += count;
|
|
os.write(data, 0, count);
|
|
}
|
|
|
|
os.flush();
|
|
os.close();
|
|
is.close();
|
|
|
|
mDownloadStatus = DOWNLOAD_STATUS_SUCCESS;
|
|
|
|
/*runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
Toast.makeText(
|
|
MainActivity.this,
|
|
"다운로드가 완료되었습니다.",
|
|
Toast.LENGTH_SHORT
|
|
).show();
|
|
}
|
|
});*/
|
|
}
|
|
}
|
|
|
|
public AudioFilePlayer() {
|
|
mPlayMode = "tts";
|
|
// mMediaPlayer = new MediaPlayer();
|
|
// AudioAttributes aa = new AudioAttributes.Builder() .setUsage(AudioAttributes.USAGE_ALARM) .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH) .build();
|
|
// mMediaPlayer.setAudioAttributes(aa);
|
|
// mMediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
|
|
// @Override
|
|
// public void onCompletion(MediaPlayer mediaPlayer) {
|
|
// if(!mChimeUpDone) {
|
|
// mChimeUpDone = true;
|
|
// return;
|
|
// }
|
|
// if(mProgress < mLastProgress) {
|
|
// mProgress++;
|
|
// return;
|
|
// }
|
|
// if(!mChimeDownDone) {
|
|
// mChimeDownDone = true;
|
|
// return;
|
|
// }
|
|
// }
|
|
// });
|
|
//
|
|
// mMediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
|
|
// @Override
|
|
// public boolean onError(MediaPlayer mediaPlayer, int i, int i1) {
|
|
// return false;
|
|
// }
|
|
// });
|
|
|
|
|
|
|
|
mExoPlayer = new ExoPlayer.Builder(MainActivity.INSTANCE).build();
|
|
mExoPlayer.addListener(new Player.Listener() {
|
|
@Override
|
|
public void onTimelineChanged(
|
|
Timeline timeline, @Player.TimelineChangeReason int reason) {
|
|
Object manifest = mExoPlayer.getCurrentManifest();
|
|
if (manifest != null) {
|
|
HlsManifest hlsManifest = (HlsManifest) manifest;
|
|
// Do something with the manifest.
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPlayerError(PlaybackException error) {
|
|
// 오류 처리
|
|
switch (error.errorCode) {
|
|
case PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED:
|
|
// 네트워크 연결 오류 처리
|
|
Log.e("ExoPlayer", "Network connection error: " + error.getMessage());
|
|
break;
|
|
|
|
case PlaybackException.ERROR_CODE_DECODING_FAILED:
|
|
// 디코딩 오류 처리
|
|
Log.e("ExoPlayer", "Decoding error: " + error.getMessage());
|
|
break;
|
|
|
|
default:
|
|
// 그 외의 오류 처리
|
|
Log.e("ExoPlayer", "Playback error: " + error.getMessage());
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPlaybackStateChanged(int playbackState) {
|
|
if (playbackState == Player.STATE_ENDED) {
|
|
// 재생 완료 이벤트 처리
|
|
if(!mChimeUpDone) {
|
|
mChimeUpDone = true;
|
|
return;
|
|
}
|
|
if(mProgress < mLastProgress) {
|
|
mProgress++;
|
|
return;
|
|
}
|
|
if(!mChimeDownDone) {
|
|
mChimeDownDone = true;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setDownloadPath(String ttsPath) {
|
|
mTTSPath = ttsPath;
|
|
}
|
|
public void setPlayCount(int count) {
|
|
mLastProgress = count;
|
|
}
|
|
public void setPlayVolume(int volume) {
|
|
mPlayVolume = volume;
|
|
}
|
|
public void terminate() {
|
|
mIsAlive = false;
|
|
}
|
|
|
|
public void resetPlayer() {
|
|
mChimeUpDone = false;
|
|
mChimeDownDone = false;
|
|
mProgress = 0;
|
|
mLastProgress = 0;
|
|
mTTSPath = null;
|
|
}
|
|
|
|
public void setPlayMode(String mode) {
|
|
mPlayMode = mode;
|
|
}
|
|
|
|
public void setPlayTarget(String target) {
|
|
mPlayTarget = target;
|
|
}
|
|
|
|
public void playAssetAudio(String assetName) {
|
|
// try {
|
|
// if(!assetName.endsWith(".wav"))
|
|
// assetName += ".wav";
|
|
//
|
|
// AssetFileDescriptor afd = getAssets().openFd(assetName);
|
|
// mMediaPlayer.reset();
|
|
// mMediaPlayer.setDataSource(afd);
|
|
// afd.close();
|
|
// mMediaPlayer.prepare();
|
|
// mMediaPlayer.start();
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
|
|
if(!assetName.endsWith(".wav"))
|
|
assetName += ".wav";
|
|
|
|
playExoWithAsset(assetName);
|
|
}
|
|
|
|
public void playExoWithAsset(final String urlName) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
MediaSource mediaSource = buildMediaSource(urlName);
|
|
mExoPlayer.setMediaSource(mediaSource);
|
|
mExoPlayer.prepare();
|
|
mExoPlayer.play();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void playExoWithUrl(final String urlName) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
MediaSource mediaSource = buildMediaSource(urlName);
|
|
mExoPlayer.setMediaItem(MediaItem.fromUri(urlName));
|
|
mExoPlayer.prepare();
|
|
mExoPlayer.play();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void playExoWithItem(final MediaItem item) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mExoPlayer.setMediaItem(item);
|
|
mExoPlayer.prepare();
|
|
mExoPlayer.play();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void stopExoPlayer() {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mExoPlayer.stop();
|
|
//mExoPlayer.release();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void playAudioPath(String urlName) {
|
|
// try {
|
|
// mMediaPlayer.reset();
|
|
// mMediaPlayer.setDataSource(urlName);
|
|
// mMediaPlayer.prepare();
|
|
// mMediaPlayer.start();
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
|
|
playExoWithUrl(urlName);
|
|
/*
|
|
File file = new File(urlName);
|
|
Uri fileUri = Uri.fromFile(file);
|
|
MediaItem item = MediaItem.fromUri(fileUri);
|
|
//mExoPlayer.setMediaSource(urlName);
|
|
mExoPlayer.setMediaItem(item);
|
|
mExoPlayer.prepare();
|
|
mExoPlayer.play();
|
|
*/
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
if(mPlayMode.equalsIgnoreCase("asset")) {
|
|
playAssetAudio(mPlayTarget);
|
|
return;
|
|
}
|
|
|
|
if(mPlayMode.equalsIgnoreCase("path")) {
|
|
playAudioPath(mPlayTarget);
|
|
return;
|
|
}
|
|
|
|
if(mTTSPath == null)
|
|
return;
|
|
|
|
mIsAlive = true;
|
|
if(!mIsDeviceOSIC10) {
|
|
setMainPlayerVolume(0);
|
|
} else {
|
|
setSpeakerVolume(mPlayVolume);
|
|
String volume = SystemUtil.getConfigValue("dacvolume");
|
|
if(volume.length() == 0) {
|
|
mLastDacVolume = 100;
|
|
}
|
|
}
|
|
|
|
boolean allowUntrusted = true;
|
|
OkHttpClient client = new OkHttpClient();
|
|
OkHttpClient.Builder clientBuilder = client.newBuilder().readTimeout(10, TimeUnit.SECONDS);
|
|
if(allowUntrusted) {
|
|
final TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
|
|
@Override
|
|
public X509Certificate[] getAcceptedIssuers() {
|
|
X509Certificate[] cArrr = new X509Certificate[0];
|
|
return cArrr;
|
|
}
|
|
|
|
@Override
|
|
public void checkServerTrusted(final X509Certificate[] chain,
|
|
final String authType) throws CertificateException {
|
|
}
|
|
|
|
@Override
|
|
public void checkClientTrusted(final X509Certificate[] chain,
|
|
final String authType) throws CertificateException {
|
|
}
|
|
}};
|
|
|
|
|
|
try {
|
|
SSLContext sslContext = SSLContext.getInstance("SSL");
|
|
|
|
sslContext.init(null, trustAllCerts, new SecureRandom());
|
|
clientBuilder.sslSocketFactory(sslContext.getSocketFactory());
|
|
|
|
HostnameVerifier hostnameVerifier = new HostnameVerifier() {
|
|
@Override
|
|
public boolean verify(String hostname, SSLSession session) {
|
|
Log.d(TAG, "Trust Host :" + hostname);
|
|
return true;
|
|
}
|
|
};
|
|
clientBuilder.hostnameVerifier( hostnameVerifier);
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
OkHttpClient httpClient = clientBuilder.build();
|
|
CallbackToDownloadFile cb = new CallbackToDownloadFile("/mnt/obb", "tts.wav");
|
|
|
|
Request request = new Request.Builder()
|
|
.url(mTTSPath)
|
|
.build();
|
|
|
|
httpClient.newCall(request).enqueue(cb);
|
|
|
|
/*int downloadId = PRDownloader.download(mTTSPath, "/mnt/obb", "tts.wav")
|
|
.build()
|
|
.setOnStartOrResumeListener(new OnStartOrResumeListener() {
|
|
@Override
|
|
public void onStartOrResume() {
|
|
|
|
}
|
|
})
|
|
.setOnPauseListener(new OnPauseListener() {
|
|
@Override
|
|
public void onPause() {
|
|
|
|
}
|
|
})
|
|
.setOnCancelListener(new OnCancelListener() {
|
|
@Override
|
|
public void onCancel() {
|
|
|
|
}
|
|
})
|
|
.setOnProgressListener(new OnProgressListener() {
|
|
@Override
|
|
public void onProgress(Progress progress) {
|
|
|
|
}
|
|
})
|
|
.start(new OnDownloadListener() {
|
|
public void onDownloadComplete() {
|
|
Log.i(TAG, "TTS Download Complete");
|
|
mDownloadStatus = DOWNLOAD_STATUS_SUCCESS;
|
|
}
|
|
|
|
@Override
|
|
public void onError(Error error) {
|
|
Log.w(TAG, "Error while TTS Download!");
|
|
mDownloadStatus = DOWNLOAD_STATUS_FAILED;
|
|
}
|
|
});*/
|
|
|
|
while(mDownloadStatus == DOWNLOAD_STATUS_PROCESS) {
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
if(!mIsAlive) {
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
return;
|
|
}
|
|
|
|
if(mDownloadStatus == DOWNLOAD_STATUS_FAILED) {
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
return;
|
|
}
|
|
|
|
if(mIsDeviceOSIC10)
|
|
{
|
|
mIsRitoPlayerOver = false;
|
|
mPlayer.openUrl(0, "/system/media/upchimes.wav");
|
|
while (!mIsRitoPlayerOver) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
mPlayer.stop();
|
|
setTTSViewVisibility(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
mProgress = 0;
|
|
while (mProgress < mLastProgress)
|
|
{
|
|
int curProgress = mProgress;
|
|
mIsRitoPlayerOver = false;
|
|
mPlayer.openUrl(0, "/mnt/obb/tts.wav");
|
|
while (!mIsRitoPlayerOver) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
mPlayer.stop();
|
|
setTTSViewVisibility(false);
|
|
return;
|
|
}
|
|
}
|
|
mProgress++;
|
|
}
|
|
|
|
mIsRitoPlayerOver = false;
|
|
mPlayer.openUrl(0, "/system/media/downchimes.wav");
|
|
while (!mIsRitoPlayerOver) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
mPlayer.stop();
|
|
setTTSViewVisibility(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
setTTSViewVisibility(false);
|
|
} else {
|
|
|
|
playAssetAudio("upchimes.wav");
|
|
|
|
while (!mChimeUpDone) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
// mMediaPlayer.stop();
|
|
// mMediaPlayer.release();
|
|
|
|
stopExoPlayer();
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
while (mProgress < mLastProgress) {
|
|
int curProgress = mProgress;
|
|
stopExoPlayer();
|
|
//mMediaPlayer.reset();
|
|
// try {
|
|
// mMediaPlayer.setDataSource("/mnt/obb/tts.wav");
|
|
// mMediaPlayer.prepare();
|
|
// mMediaPlayer.start();
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
playAudioPath("/mnt/obb/tts.wav");
|
|
|
|
while (curProgress == mProgress) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
//mMediaPlayer.stop();
|
|
stopExoPlayer();
|
|
//mMediaPlayer.release();
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
return;
|
|
}
|
|
}
|
|
|
|
try {
|
|
sleep(1000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
// try {
|
|
// AssetFileDescriptor afd = getAssets().openFd("downchimes.wav");
|
|
// mMediaPlayer.reset();
|
|
// mMediaPlayer.setDataSource(afd);
|
|
// afd.close();
|
|
// mMediaPlayer.prepare();
|
|
// mMediaPlayer.start();
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
playAssetAudio("downchimes.wav");
|
|
|
|
while (!mChimeDownDone) {
|
|
try {
|
|
sleep(10);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
if (!mIsAlive) {
|
|
stopExoPlayer();
|
|
// mMediaPlayer.stop();
|
|
// mMediaPlayer.release();
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
return;
|
|
}
|
|
}
|
|
|
|
stopExoPlayer();
|
|
// mMediaPlayer.stop();
|
|
// mMediaPlayer.release();
|
|
|
|
setTTSViewVisibility(false);
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyUp(int keyCode, KeyEvent event)
|
|
{
|
|
Log.w(TAG, "keyUpCode : " + keyCode);
|
|
if(event.getKeyCode() == KeyEvent.KEYCODE_BUTTON_12) { // VFD KEY OKAY
|
|
long keyTime = SystemClock.uptimeMillis();
|
|
if(keyTime - mKeyPressTime > 2000) {
|
|
//Log.w(TAG, "keyLongUpCode : " + keyCode);
|
|
//mVfdManager.cancelVfdChangeMode();
|
|
//Log.w(TAG, "Vfd Change Mode Cancelled!");
|
|
} else {
|
|
if(!mVfdManager.mVfdChangeMode)
|
|
mVfdManager.toggleVfdChangeMode();
|
|
else
|
|
mVfdManager.cancelVfdChangeMode(); // short OKAY Key -> Cancel
|
|
//Log.w(TAG, "keyUpCode : " + keyCode);
|
|
// if(mVfdManager.mVfdConfirmMode) {
|
|
// mVfdManager.confirmSettingValue();
|
|
// mVfdManager.mVfdChangeMode = false;
|
|
// mVfdManager.mVfdConfirmMode = false;
|
|
// } else {
|
|
// mVfdManager.toggleVfdChangeMode();
|
|
// }
|
|
}
|
|
mKeyPressTime = 0;
|
|
return true;
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_CHANNEL_UP) { // CHANNEL-UP
|
|
if(mJsonScheduler != null) {
|
|
mJsonScheduler.advancePlayNext(1);
|
|
}
|
|
return true;
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_CHANNEL_DOWN) { // CHANNEL-DOWN
|
|
if(mJsonScheduler != null) {
|
|
mJsonScheduler.advancePlayNext(-1);
|
|
}
|
|
return true;
|
|
}
|
|
return super.onKeyUp(keyCode, event);
|
|
}
|
|
|
|
public void sendMqttMsg(String topic, String message) {
|
|
Log.w("MQTT", "[SEND] <" + topic + "> " + message);
|
|
MqttMessage mqttMsg = new MqttMessage(message.getBytes());
|
|
try {
|
|
mqttAndroidClient.publish(topic, mqttMsg);
|
|
} catch (MqttException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public void handleDsrConfirm() {
|
|
try {
|
|
JSONObject topObject = new JSONObject();
|
|
topObject.put("status", "confirm");
|
|
topObject.put("ward_id", mWardId);
|
|
topObject.put("dsr_seq", mDsrSeq);
|
|
|
|
sendMqttMsg("ebcast/device/notify", topObject.toString());
|
|
mDsrSeq = "";
|
|
} catch(Exception e) {
|
|
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onKeyDown(int keyCode, KeyEvent event) {
|
|
if(event.getKeyCode() != 199) {
|
|
Log.w(TAG, "keyCode : " + keyCode);
|
|
}
|
|
|
|
if(mWardId != null && mWardId.length() > 0 && mDsrSeq != null && mDsrSeq.length() > 0) {
|
|
if(event.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER) { // 지령 확인
|
|
handleDsrConfirm();
|
|
}
|
|
}
|
|
|
|
if(event.getKeyCode() == 200) { // VFD KEY LEFT
|
|
//mVfdManager.vfdDrawString(getIPAddress(), 1, mVfdManager.VFD_ALIGN_CENTER);
|
|
mVfdManager.moveSettingMode(-1);
|
|
return true;
|
|
} else if(event.getKeyCode() == 201) { // VFD KEY RIGHT
|
|
mVfdManager.moveSettingMode(1);
|
|
return true;
|
|
} else if(event.getKeyCode() == 202) { // VFD KEY UP
|
|
mVfdManager.changeSettingValue(1);
|
|
return true;
|
|
} else if(event.getKeyCode() == 203) { // VFD KEY DOWN
|
|
mVfdManager.changeSettingValue(-1);
|
|
return true;
|
|
} else if(event.getKeyCode() == 199) { // VFD KEY OKAY
|
|
//mVfdManager.toggleVfdChangeMode();
|
|
if(mKeyPressTime == 0) {
|
|
mKeyPressTime = SystemClock.uptimeMillis();
|
|
} else {
|
|
if(SystemClock.uptimeMillis() - mKeyPressTime > 2000) {
|
|
//mVfdManager.cancelVfdChangeMode();
|
|
if(mVfdManager.mVfdChangeMode)
|
|
mVfdManager.toggleVfdChangeMode();
|
|
}
|
|
}
|
|
return true;
|
|
} else if(event.getKeyCode() == 183) { // SETUP KEY
|
|
Intent intent = new Intent(this, SettingActivity.class);
|
|
startActivity(intent);
|
|
return true;
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_F12) { // Volume-Up
|
|
String volume = SystemUtil.getConfigValue("spkvolume");
|
|
if(volume.length() == 0) {
|
|
volume = "100";
|
|
} else {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
volumeInt++;
|
|
volume = "" + volumeInt;
|
|
}
|
|
SystemUtil.setConfigValue("spkvolume", volume);
|
|
return true;
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_F11) { // Volume-Down
|
|
String volume = SystemUtil.getConfigValue("spkvolume");
|
|
if(volume.length() == 0) {
|
|
volume = "99";
|
|
} else {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
volumeInt--;
|
|
if(volumeInt < 0)
|
|
volumeInt = 0;
|
|
volume = "" + volumeInt;
|
|
}
|
|
SystemUtil.setConfigValue("spkvolume", volume);
|
|
return true;
|
|
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_PROG_YELLOW) { // Video-Volume-down
|
|
String volume = SystemUtil.getConfigValue("videovolume");
|
|
if(volume.length() == 0) {
|
|
volume = "11";
|
|
} else {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
volumeInt--;
|
|
if(volumeInt < 1)
|
|
volumeInt = 1;
|
|
volume = "" + volumeInt;
|
|
}
|
|
SystemUtil.setConfigValue("videovolume", volume);
|
|
return true;
|
|
} else if(event.getKeyCode() == KeyEvent.KEYCODE_PROG_BLUE) { // Volume-Volume-Up
|
|
String volume = SystemUtil.getConfigValue("videovolume");
|
|
if(volume.length() == 0) {
|
|
volume = "13";
|
|
} else {
|
|
int volumeInt = Integer.parseInt(volume);
|
|
volumeInt++;
|
|
if(volumeInt >= 15)
|
|
volumeInt = 15;
|
|
volume = "" + volumeInt;
|
|
}
|
|
SystemUtil.setConfigValue("videovolume", volume);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setWaitViewVisibility(final boolean show) {
|
|
final ImageView view = (ImageView)findViewById(R.id.imageViewWait);
|
|
if(show) {
|
|
if(view.getAlpha() == 0.0f) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.setAlpha(1.0f);
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
if(view.getAlpha() != 0.0f) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.setAlpha(0.0f);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
// runOnUiThread(new Runnable() {
|
|
// @Override
|
|
// public void run() {
|
|
// if(show) {
|
|
// view.setAlpha(1.0f);
|
|
// } else {
|
|
// view.setAlpha(0.0f);
|
|
// }
|
|
// }
|
|
// });
|
|
}
|
|
|
|
public void setTTSViewVisibility(final boolean show) {
|
|
if(mIsDeviceOSIC10) {
|
|
mIsOnTTSPlaying = show;
|
|
return;
|
|
}
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
ImageView view = (ImageView)findViewById(R.id.imageViewTts);
|
|
if(show) {
|
|
view.setAlpha(1.0f);
|
|
mIsOnTTSPlaying = true;
|
|
} else {
|
|
view.setAlpha(0.0f);
|
|
mIsOnTTSPlaying = false;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setWebViewUrl(String url) {
|
|
WebView view = (WebView)findViewById(R.id.webview);
|
|
view.loadUrl(url);
|
|
}
|
|
|
|
public void setWebViewVisibility(final boolean show) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
WebView view = (WebView)findViewById(R.id.webview);
|
|
if(show) {
|
|
view.setVisibility(View.VISIBLE);
|
|
view.setAlpha(1.0f);
|
|
} else {
|
|
view.setAlpha(0.0f);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
public void setWebViewLoadingVisibility(final boolean show) {
|
|
final ImageView view = (ImageView)findViewById(R.id.imageViewLoading);
|
|
if(show) {
|
|
if(view.getAlpha() == 0.0f) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.setAlpha(1.0f);
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
if(view.getAlpha() != 0.0f) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.setAlpha(0.0f);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public void setMainPlayerVolume(int volume) {
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mVlcPlayer != null) {
|
|
mVlcVolume = volume;
|
|
mVlcPlayer.setVolume(volume);
|
|
//Log.i(TAG, "VLC Volume Setting : " + volume);
|
|
|
|
if(mIsDeviceOSIC10) {
|
|
AudioManager audioManager = (AudioManager) this.getSystemService(Context.AUDIO_SERVICE);
|
|
if (volume == 0) {
|
|
//audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, 0, 0);
|
|
audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, AudioManager.ADJUST_MUTE, 0);
|
|
} else {
|
|
audioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC, AudioManager.ADJUST_UNMUTE, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* 표시 버전 1 */
|
|
public void handleNotifyScreenOrder(String msgType, final String msgDatetime, final String msgAddress, final String msgDesc, String msgVehicle) {
|
|
final String msgTypeShow;
|
|
final Bitmap bitmap;
|
|
if(msgType.equalsIgnoreCase("fire")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/fire.png");
|
|
shellCommand("miscctrl function_led red on");
|
|
msgTypeShow = "화재";
|
|
} else if(msgType.equalsIgnoreCase("emergency")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/emer.png");
|
|
shellCommand("miscctrl function_led green on");
|
|
msgTypeShow = "구급";
|
|
} else if(msgType.equalsIgnoreCase("rescue")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/rescue.png");
|
|
shellCommand("miscctrl function_led red on");
|
|
shellCommand("miscctrl function_led green on");
|
|
msgTypeShow = "구조";
|
|
} else {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/general.png");
|
|
msgTypeShow = "일반";
|
|
shellCommand("miscctrl function_led blue on");
|
|
}
|
|
|
|
final String msgVehicleShow = msgVehicle.replace('|', '\n');
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
ImageView imageView = findViewById(R.id.imageViewCmdBack);
|
|
imageView.setImageBitmap(bitmap);
|
|
imageView.setVisibility(View.VISIBLE);
|
|
SurfaceView surfaceView = findViewById(R.id.surfaceViewCmd);
|
|
surfaceView.setVisibility(View.VISIBLE);
|
|
surfaceView.setZOrderOnTop(true);
|
|
surfaceView.getHolder().setFormat(PixelFormat.TRANSPARENT);
|
|
Canvas canvas = surfaceView.getHolder().lockCanvas();
|
|
if(canvas != null) {
|
|
float textSize = 50;
|
|
float textBaseX = 470;
|
|
float textBaseY = 145;
|
|
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
paint.setColor(Color.BLACK);
|
|
//paint.setTextSize(48);
|
|
paint.setTextSize(textSize);
|
|
paint.setFakeBoldText(true);
|
|
paint.setTextAlign(Paint.Align.LEFT);
|
|
// Rect bounds = new Rect();
|
|
// paint.getTextBounds(text, 0, text.length(), bounds);
|
|
// // Calculate the desired size as a proportion of our testTextSize.
|
|
// float desiredTextSize = testTextSize * desiredWidth / bounds.width();
|
|
// // Set the paint for that size.
|
|
// paint.setTextSize(desiredTextSize);
|
|
|
|
float gap = 92;
|
|
//canvas.drawText("종별종별종별", 470, 160, paint);
|
|
canvas.drawText(msgTypeShow, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2), paint);
|
|
canvas.drawText(msgDatetime, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap, paint);
|
|
canvas.drawText(msgAddress, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap * 2, paint);
|
|
|
|
//canvas.drawText(msgDesc, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap * 3, paint);
|
|
textSize = 50;
|
|
do {
|
|
TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
|
|
textPaint.setColor(Color.BLACK);
|
|
textPaint.setTextSize(textSize);
|
|
textPaint.setFakeBoldText(true);
|
|
textPaint.setTextAlign(Paint.Align.LEFT);
|
|
StaticLayout textLayout = new StaticLayout(msgDesc, textPaint, 930, Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
|
|
if(textLayout.getHeight() > 180) {
|
|
textSize -= 1;
|
|
continue;
|
|
}
|
|
canvas.save();
|
|
canvas.translate(textBaseX, textBaseY + gap * 3 - 25);
|
|
textLayout.draw(canvas);
|
|
canvas.restore();
|
|
break;
|
|
} while(true);
|
|
|
|
//canvas.drawText(msgVehicleShow, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap * 5 + 10, paint);
|
|
textSize = 50;
|
|
do {
|
|
TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
|
|
textPaint.setColor(Color.BLACK);
|
|
textPaint.setTextSize(textSize);
|
|
textPaint.setFakeBoldText(true);
|
|
textPaint.setTextAlign(Paint.Align.LEFT);
|
|
StaticLayout textLayout = new StaticLayout(msgVehicleShow, textPaint, 930, Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
|
|
if(textLayout.getHeight() > 370) {
|
|
textSize -= 1;
|
|
continue;
|
|
}
|
|
canvas.save();
|
|
canvas.translate(textBaseX, textBaseY + gap * 5 - 25);
|
|
textLayout.draw(canvas);
|
|
canvas.restore();
|
|
break;
|
|
} while(true);
|
|
|
|
surfaceView.getHolder().unlockCanvasAndPost(canvas);
|
|
} else {
|
|
Log.w(TAG, "Canvas is null!");
|
|
}
|
|
findViewById(R.id.layoutCommand).setVisibility(View.VISIBLE);
|
|
//findViewById(R.id.layoutCommand).setAlpha(1.0f);
|
|
mNotifyMsgStartTime = SystemClock.uptimeMillis();
|
|
mIsOnNotifyMsg = true;
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mVlcPlayer != null) {
|
|
setMainPlayerVolume(0);
|
|
}
|
|
}
|
|
//bitmap.recycle();
|
|
// findViewById(R.id.layoutCommand).bringToFront();
|
|
// findViewById(R.id.layoutCommand).setZ(500);
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
|
|
/* 표시 버전 2 */
|
|
public void handleNotifyScreenOrder(String msgType,
|
|
final String msgDsrClass,
|
|
final String msgDsrSize,
|
|
final String msgDatetime,
|
|
final String msgAddressDoro,
|
|
final String msgAddressJibun,
|
|
final String msgDesc,
|
|
String msgVehicle)
|
|
{
|
|
final String msgTypeShow;
|
|
final Bitmap bitmap;
|
|
if(msgType.equalsIgnoreCase("fire")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/fire.png");
|
|
shellCommand("miscctrl function_led green off");
|
|
shellCommand("miscctrl function_led blue off");
|
|
shellCommand("miscctrl function_led red on");
|
|
} else if(msgType.equalsIgnoreCase("emergency")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/emer.png");
|
|
shellCommand("miscctrl function_led red off");
|
|
shellCommand("miscctrl function_led blue off");
|
|
shellCommand("miscctrl function_led green on");
|
|
} else if(msgType.equalsIgnoreCase("rescue")) {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/rescue.png");
|
|
shellCommand("miscctrl function_led blue off");
|
|
shellCommand("miscctrl function_led red on");
|
|
shellCommand("miscctrl function_led green on");
|
|
} else {
|
|
bitmap = BitmapFactory.decodeFile("/mnt/sdcard/osic/general.png");
|
|
shellCommand("miscctrl function_led red off");
|
|
shellCommand("miscctrl function_led green off");
|
|
shellCommand("miscctrl function_led blue on");
|
|
}
|
|
|
|
final String msgVehicleShow = msgVehicle.replace("|", ", ");
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
ImageView imageView = findViewById(R.id.imageViewCmdBack);
|
|
imageView.setImageBitmap(bitmap);
|
|
imageView.setVisibility(View.VISIBLE);
|
|
SurfaceView surfaceView = findViewById(R.id.surfaceViewCmd);
|
|
surfaceView.setVisibility(View.VISIBLE);
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
SurfaceView surfaceView = findViewById(R.id.surfaceViewCmd);
|
|
surfaceView.setZOrderOnTop(true);
|
|
surfaceView.getHolder().setFormat(PixelFormat.TRANSPARENT);
|
|
Canvas canvas = surfaceView.getHolder().lockCanvas();
|
|
if (canvas != null) {
|
|
float textClassSize = 96;
|
|
float textClassBaseX = 1430;
|
|
float textClassBaseY = 125;
|
|
float textSize = 46;
|
|
float textBaseX = 360;
|
|
float textBaseY = 215;
|
|
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
|
|
|
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
|
|
|
|
paint.setFakeBoldText(true);
|
|
paint.setTextAlign(Paint.Align.CENTER);
|
|
paint.setColor(Color.WHITE);
|
|
do {
|
|
TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
|
|
textPaint.setColor(Color.BLACK);
|
|
textPaint.setTextSize(textClassSize);
|
|
textPaint.setTextAlign(Paint.Align.LEFT);
|
|
float textWidth = textPaint.measureText(msgDsrClass);
|
|
if (textWidth > 910) {
|
|
textClassSize -= 1;
|
|
continue;
|
|
}
|
|
break;
|
|
} while (true);
|
|
paint.setTextSize(textClassSize);
|
|
canvas.drawText(msgDsrClass, textClassBaseX, textClassBaseY, paint);
|
|
|
|
paint.setTextAlign(Paint.Align.LEFT);
|
|
paint.setColor(Color.BLACK);
|
|
paint.setTextSize(textSize);
|
|
|
|
float gap = 75;
|
|
canvas.drawText(msgDatetime, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2), paint);
|
|
canvas.drawText(msgDsrSize, textBaseX + 930, textBaseY - ((paint.descent() + paint.ascent()) / 2), paint);
|
|
canvas.drawText(msgAddressDoro, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap, paint);
|
|
canvas.drawText(msgAddressJibun, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap * 2, paint);
|
|
|
|
textSize = 50;
|
|
do {
|
|
TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
|
|
textPaint.setColor(Color.BLACK);
|
|
textPaint.setTextSize(textSize);
|
|
textPaint.setFakeBoldText(true);
|
|
textPaint.setTextAlign(Paint.Align.LEFT);
|
|
StaticLayout textLayout = new StaticLayout(msgDesc, textPaint, 1200, Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
|
|
if (textLayout.getHeight() > 320) {
|
|
textSize -= 1;
|
|
continue;
|
|
}
|
|
int layoutHeight = textLayout.getHeight();
|
|
canvas.save();
|
|
canvas.translate(textBaseX, textBaseY + gap * 3 - 30 + (320 - layoutHeight) / 2);
|
|
textLayout.draw(canvas);
|
|
canvas.restore();
|
|
break;
|
|
} while (true);
|
|
|
|
//canvas.drawText(msgVehicleShow, textBaseX, textBaseY - ((paint.descent() + paint.ascent()) / 2) + gap * 5 + 10, paint);
|
|
textSize = 50;
|
|
do {
|
|
TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
|
|
textPaint.setColor(Color.BLACK);
|
|
textPaint.setTextSize(textSize);
|
|
textPaint.setFakeBoldText(true);
|
|
textPaint.setTextAlign(Paint.Align.LEFT);
|
|
//StaticLayout textLayout = new StaticLayout(msgVehicleShow, textPaint, 530, Layout.Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false);
|
|
StaticLayout.Builder builder = StaticLayout.Builder.obtain(msgVehicleShow, 0, msgVehicleShow.length(), textPaint, 1200)
|
|
.setAlignment(Layout.Alignment.ALIGN_NORMAL)
|
|
.setLineSpacing(0.0f, 1.0f)
|
|
.setIncludePad(false)
|
|
.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE)
|
|
.setBreakStrategy(LineBreaker.BREAK_STRATEGY_SIMPLE)
|
|
.setMaxLines(5);
|
|
StaticLayout textLayout = builder.build();
|
|
|
|
|
|
if (textLayout.getHeight() > 200) {
|
|
textSize -= 1;
|
|
continue;
|
|
}
|
|
int layoutHeight = textLayout.getHeight();
|
|
canvas.save();
|
|
canvas.translate(textBaseX, textBaseY + gap * 7 + 10 + (210 - layoutHeight) / 2);
|
|
textLayout.draw(canvas);
|
|
canvas.restore();
|
|
break;
|
|
} while (true);
|
|
|
|
surfaceView.getHolder().unlockCanvasAndPost(canvas);
|
|
|
|
Log.w(TAG, "======================");
|
|
Log.w(TAG, " 지령표출화면 표시시작 ");
|
|
Log.w(TAG, "======================");
|
|
} else {
|
|
Log.w(TAG, "Canvas is null!");
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}.start();
|
|
|
|
findViewById(R.id.layoutCommand).setVisibility(View.VISIBLE);
|
|
mNotifyMsgStartTime = SystemClock.uptimeMillis();
|
|
mIsOnNotifyMsg = true;
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mVlcPlayer != null) {
|
|
setMainPlayerVolume(0);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
}
|
|
|
|
public void doStoredScheduleUpdate(String target) {
|
|
if(target.equalsIgnoreCase("ip")) {
|
|
JsonResult jsonResult = JsonManager.loadJsonData("ip-schedule.json");
|
|
if (jsonResult != null) {
|
|
MainActivity.INSTANCE.mJsonScheduler.updateJsonTargetResult("ip", jsonResult);
|
|
}
|
|
} else if(target.equalsIgnoreCase("file")) {
|
|
JsonResult jsonResult = JsonManager.loadJsonData("file-schedule.json");
|
|
if (jsonResult != null) {
|
|
MainActivity.INSTANCE.mJsonScheduler.updateJsonTargetResult("file", jsonResult);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setupVlcMediaOption(Media m) {
|
|
String optValue = SystemUtil.property_get("sys.rito.net.cache");
|
|
if(optValue == null || optValue.length() == 0)
|
|
optValue = "" + VLC_NETWORK_CACHE_DEFAULT;
|
|
m.addOption(":network-caching=" + optValue);
|
|
|
|
optValue = SystemUtil.property_get("sys.rito.live.cache");
|
|
if(optValue == null || optValue.length() == 0)
|
|
optValue = "" + VLC_LIVE_CACHE_DEFAULT;
|
|
m.addOption(":live-caching=" + optValue);
|
|
|
|
optValue = SystemUtil.property_get("sys.rito.udp.buffer");
|
|
if(optValue == null || optValue.length() == 0)
|
|
optValue = "" + VLC_UDP_BUFFER_DEFAULT;
|
|
m.addOption(":udp-buffer=" + optValue);
|
|
|
|
m.addOption(":clock-jitter=0");
|
|
m.addOption(":clock-synchro=0");
|
|
}
|
|
|
|
public void nativeNotify(int code, String info) {
|
|
Log.w(TAG, "NOTIFY Code : " + code + ", Info : " + info);
|
|
if(code == MANAGER_NOTIFY_ORDER_START_PLAYBACK) {
|
|
|
|
if(mIsDeviceOSIC10) {
|
|
if (SystemUtil.APP_MODE.equals("active")) { // Browser Mode 인 경우
|
|
return; // 서버로 부터 재생 명령 무시
|
|
}
|
|
}
|
|
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_RITO) {
|
|
mPlayer.stop();
|
|
String[] cutInfo = info.split(" ");
|
|
if (cutInfo[0].startsWith("mc://")) {
|
|
cutInfo[0] = cutInfo[0].replace("mc://", "udp://");
|
|
cutInfo[0] = cutInfo[0].replace("_", ":");
|
|
}
|
|
SurfaceView view = findViewById(R.id.playerView);
|
|
mPlayer.mSurfaceView = view;
|
|
mPlayer.openUrl(0, cutInfo[0]);
|
|
} else if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
String[] cutInfo = info.split(" ");
|
|
if (cutInfo[0].startsWith("mc://")) {
|
|
cutInfo[0] = cutInfo[0].replace("mc://", "udp://");
|
|
// if(!cutInfo[0].contains("@")) {
|
|
// cutInfo[0] = cutInfo[0].replace("udp://", "udp://@");
|
|
// }
|
|
cutInfo[0] = cutInfo[0].replace("_", ":").trim();
|
|
String[] partSplit = cutInfo[0].substring(6).split(":");
|
|
if(!partSplit[0].startsWith("2")) {
|
|
cutInfo[0] = "udp://@:" + partSplit[1];
|
|
} else {
|
|
cutInfo[0] = "udp://@" + partSplit[0] + ":" + partSplit[1];
|
|
}
|
|
} else if (cutInfo[0].startsWith("hsact://")) {
|
|
cutInfo[0] = cutInfo[0].replace("hsact://", "rtsp://").trim();
|
|
}
|
|
Log.w(TAG, "VLCPlayer URL : " + cutInfo[0]);
|
|
mLastPlayUrl = cutInfo[0];
|
|
if(mCurrentPlayUrl == null || !cutInfo[0].equals(mCurrentPlayUrl)) {
|
|
mVlcPlayer.stop();
|
|
Media m = new Media(mVLC, Uri.parse(cutInfo[0]));
|
|
if(mIsDeviceOSIC10) {
|
|
setupVlcMediaOption(m);
|
|
}
|
|
mVlcPlayer.setMedia(m);
|
|
mVLCMedia = m;
|
|
mVlcPlayer.play();
|
|
mCurrentPlayUrl = cutInfo[0];
|
|
}
|
|
}
|
|
setTTSViewVisibility(false);
|
|
setWaitViewVisibility(false);
|
|
} else if(code == MANAGER_NOTIFY_ORDER_STOP_PLAYBACK) {
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_RITO) {
|
|
mPlayer.stop();
|
|
} else if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mIsDeviceOSIC10) {
|
|
mLastPlayUrl = null;
|
|
}
|
|
mVlcPlayer.stop();
|
|
try {
|
|
AssetFileDescriptor afd = getAssets().openFd("blackground.png");
|
|
mVlcPlayer.play(afd);
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
if(!SystemUtil.APP_MODE.equals("active")) { // Browser Mode 아닌경우
|
|
setWaitViewVisibility(true);
|
|
}
|
|
|
|
/*MediaPlayer player = MediaPlayer.create(this, R.raw.upchimes);
|
|
player.start();*/
|
|
/*MediaPlayer player2 = MediaPlayer.create(this, R.raw.downchimes);
|
|
player2.start();*/
|
|
|
|
} else if(code == MANAGER_NOTIFY_ORDER_START_TTS) {
|
|
if(mTTSPlayer != null) {
|
|
mTTSPlayer.terminate();
|
|
}
|
|
mTTSPlayer = new AudioFilePlayer();
|
|
mTTSPlayer.resetPlayer();
|
|
|
|
String[] tokenList = info.split("\r\n");
|
|
for(String token : tokenList) {
|
|
String[] split = token.split("=");
|
|
if(split.length == 2) {
|
|
if(split[0].equalsIgnoreCase("URL")) {
|
|
mTTSPlayer.setDownloadPath(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("COUNT")) {
|
|
mTTSPlayer.setPlayCount(Integer.parseInt(split[1]));
|
|
} else if(split[0].equalsIgnoreCase("TTS_VOLUME")) {
|
|
mTTSPlayer.setPlayVolume(Integer.parseInt(split[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_RITO) {
|
|
mPlayer.stop();
|
|
} else if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
mVlcPlayer.stop();
|
|
}
|
|
*/
|
|
|
|
setTTSViewVisibility(true);
|
|
|
|
|
|
mTTSPlayer.start();
|
|
} else if(code == MANAGER_NOTIFY_ORDER_CEC_CONTROL) {
|
|
if(info.equalsIgnoreCase("on")) {
|
|
Intent intent = new Intent("kr.co.rito.factory.setting");
|
|
//intent.setClassName("kr.co.rito.factory", "SettingChanger");
|
|
intent.setComponent(new ComponentName("kr.co.rito.factory", "kr.co.rito.factory.SettingChanger"));
|
|
intent.putExtra("TYPE", "CecControl");
|
|
intent.putExtra("ORDER", "active");
|
|
sendBroadcast(intent);
|
|
} else if(info.equalsIgnoreCase("off")) {
|
|
Intent intent = new Intent("kr.co.rito.factory.setting");
|
|
intent.setComponent(new ComponentName("kr.co.rito.factory", "kr.co.rito.factory.SettingChanger"));
|
|
intent.putExtra("TYPE", "CecControl");
|
|
intent.putExtra("ORDER", "standby");
|
|
sendBroadcast(intent);
|
|
}
|
|
} else if(code == MANAGER_NOTIFY_ORDER_START_TICKER) {
|
|
String _text = "";
|
|
int _x, _y, _width, _height;
|
|
int _fcolor, _bcolor, _count;
|
|
int _speed;
|
|
_x = _y = _width = _height = _fcolor = _bcolor = _count = _speed = 0;
|
|
|
|
String[] tokenList = info.split("\r\n");
|
|
for(String token : tokenList) {
|
|
String[] split = token.split("=");
|
|
if(split.length == 2) {
|
|
if(split[0].equalsIgnoreCase("X")) {
|
|
_x = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("Y")) {
|
|
_y = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("WIDTH")) {
|
|
_width = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("HEIGHT")) {
|
|
_height = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("SPEED")) {
|
|
_speed = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("COUNT")) {
|
|
_count = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("FORE_COLOR")) {
|
|
_fcolor = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("BACK_COLOR")) {
|
|
_bcolor = Integer.parseInt(split[1]);
|
|
} else if(split[0].equalsIgnoreCase("TEXT")) {
|
|
_text = split[1];
|
|
// try {
|
|
// _text = new String(split[1].getBytes("UTF-8"));
|
|
// } catch (UnsupportedEncodingException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
|
|
_x = _x * 1920 / 1280;
|
|
_y = _y * 1080 / 720;
|
|
_width = _width * 1920 / 1280;
|
|
_height = _height * 1080 / 720;
|
|
|
|
mTickerManager.setupTicker(_text,
|
|
new Rect(_x, _y, _x + _width, _y + _height),
|
|
_fcolor, _bcolor, _count, (float)_speed);
|
|
mTickerManager.renderTicker();
|
|
} else if(code == MANAGER_NOTIFY_ORDER_JSON_ORDER) {
|
|
String jsonUrl = null;
|
|
String jsonType = null;
|
|
String[] tokenList = info.split("\r\n");
|
|
for(String token : tokenList) {
|
|
String[] split = token.split("=");
|
|
if(split.length == 2) {
|
|
if(split[0].equalsIgnoreCase("URL")) {
|
|
jsonUrl = split[1];
|
|
} else if(split[0].equalsIgnoreCase("TYPE")) {
|
|
jsonType = split[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
Log.w(TAG, "JSON TYPE : " + jsonType + ", JSON URL : " + jsonUrl);
|
|
JsonManager jsonManager = new JsonManager(this);
|
|
jsonManager.setDownloadPath( "http://" + getServerAddress() + "/" + jsonUrl);
|
|
jsonManager.start();
|
|
} else if(code == MANAGER_NOTIFY_ORDER_NOTIFY_SCREEN_ORDER) {
|
|
Log.w(TAG, "Got Notify Screen Message : " + info);
|
|
String msgType = "";
|
|
String msgDatetime = "";
|
|
String msgAddress = "";
|
|
String msgDesc = "";
|
|
String msgVehicle = "";
|
|
|
|
String msgAddressDoro = "";
|
|
String msgAddressJibun = "";
|
|
String msgDsrClass = "";
|
|
String msgDsrSize = "";
|
|
|
|
String[] tokenList = info.split("\r\n");
|
|
for(String token : tokenList) {
|
|
String[] split = token.split("=");
|
|
if(split.length == 2) {
|
|
if(split[0].equalsIgnoreCase("MSGTYPE")) {
|
|
msgType = split[1];
|
|
} else if(split[0].equalsIgnoreCase("DATETIME")) {
|
|
msgDatetime = split[1];
|
|
} else if(split[0].equalsIgnoreCase("ADDRESS")) {
|
|
msgAddress = split[1];
|
|
} else if(split[0].equalsIgnoreCase("ADDRESS-DORO")) {
|
|
msgAddressDoro = split[1];
|
|
} else if(split[0].equalsIgnoreCase("ADDRESS-JIBUN")) {
|
|
msgAddressJibun = split[1];
|
|
} else if(split[0].equalsIgnoreCase("CLASS")) {
|
|
msgDsrClass = split[1];
|
|
} else if(split[0].equalsIgnoreCase("SIZE")) {
|
|
msgDsrSize = split[1];
|
|
} else if(split[0].equalsIgnoreCase("DESC")) {
|
|
msgDesc = split[1];
|
|
} else if(split[0].equalsIgnoreCase("VEHICLE")) {
|
|
msgVehicle = split[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
/* For Demo Perpose - 2023-09-19 */
|
|
/*
|
|
msgType = "general";
|
|
msgDatetime = "2023년 9월 21일";
|
|
msgDsrClass = "";
|
|
msgDsrSize = "메이저";
|
|
msgAddressDoro = "192.168.1.100"; // IP주소
|
|
msgAddressJibun = "본청 방송실"; // 대상기관
|
|
msgDesc = "비정상적 파일시스템 용량 증가 및 네트워크 트래픽 증가";
|
|
msgVehicle = "PC악성 코드 감염 의심|네트워크 분리 및 백신 검사 필요|시스템 로그 분석 필요";
|
|
*/
|
|
|
|
if(msgAddress != null && msgAddress.length() > 0) {
|
|
handleNotifyScreenOrder(msgType, msgDatetime, msgAddress, msgDesc, msgVehicle);
|
|
} else {
|
|
handleNotifyScreenOrder(msgType,
|
|
msgDsrClass,
|
|
msgDsrSize,
|
|
msgDatetime,
|
|
msgAddressDoro,
|
|
msgAddressJibun,
|
|
msgDesc,
|
|
msgVehicle);
|
|
|
|
// Notify Screen Chime
|
|
AudioFilePlayer chimePlayer = new AudioFilePlayer();
|
|
chimePlayer.setPlayMode("asset");
|
|
if(msgType.equalsIgnoreCase("fire")) {
|
|
chimePlayer.setPlayTarget("fire");
|
|
} else if(msgType.equalsIgnoreCase("emergency")) {
|
|
chimePlayer.setPlayTarget("emergency");
|
|
} else if(msgType.equalsIgnoreCase("rescue")) {
|
|
chimePlayer.setPlayTarget("rescue");
|
|
} else {
|
|
chimePlayer.setPlayTarget("general");
|
|
}
|
|
chimePlayer.start();
|
|
}
|
|
} else if(code == MANAGER_NOTIFY_ORDER_EVENT_MESSAGE) {
|
|
//Log.w(TAG, "Got Event Message : " + info);
|
|
String evtType = null;
|
|
String evtClassId = null;
|
|
String evtBaseUrl = null;
|
|
String evtJsonRaw = null;
|
|
String[] tokenList = info.split("\r\n");
|
|
for(String token : tokenList) {
|
|
String[] split = token.split("=");
|
|
if(split.length == 2) {
|
|
if(split[0].equalsIgnoreCase("EVENT")) {
|
|
evtType = split[1];
|
|
} else if(split[0].equalsIgnoreCase("CLASS_ID")) {
|
|
evtClassId = split[1];
|
|
} else if(split[0].equalsIgnoreCase("BASE_URL")) {
|
|
evtBaseUrl = split[1];
|
|
} else if(split[0].equalsIgnoreCase("JSON_RAW")) {
|
|
evtJsonRaw = split[1];
|
|
}
|
|
}
|
|
}
|
|
|
|
if(evtType.equalsIgnoreCase("image-update")) {
|
|
if (mFileDownloader != null) {
|
|
String[] downList = {"fire.png", "rescue.png", "emer.png", "general.png"};
|
|
try {
|
|
String topClass = evtClassId.substring(0, 2) + "0000";
|
|
for (String target : downList) {
|
|
mFileDownloader.addDownloadTarget(evtBaseUrl + "/" + topClass + "-" + target, MainActivity.INSTANCE.mEmmcSavePath, target);
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
} else if(evtType.equalsIgnoreCase("channel-update")) {
|
|
//Log.w(TAG, "JSON RAW : " + evtJsonRaw);
|
|
try {
|
|
JSONObject topObject = new JSONObject(evtJsonRaw);
|
|
JSONArray jsonArray = topObject.getJSONArray("data");
|
|
for(int i = 0;i < jsonArray.length();i++) {
|
|
JSONObject jo = jsonArray.getJSONObject(i);
|
|
//Log.w(TAG, "Address : " + jo.getString("address"));
|
|
}
|
|
|
|
File saveFile = new File(MainActivity.INSTANCE.mSDSavePath + "/ip-schedule.json");
|
|
if(saveFile.exists())
|
|
saveFile.delete();
|
|
|
|
try {
|
|
saveFile.createNewFile();
|
|
OutputStream os = new FileOutputStream(saveFile);
|
|
byte[] evtData = evtJsonRaw.getBytes("utf-8");
|
|
|
|
os.write(evtData, 0, evtData.length);
|
|
os.flush();
|
|
os.close();
|
|
} catch (IOException e) {
|
|
}
|
|
|
|
MainActivity.INSTANCE.doSync();
|
|
doStoredScheduleUpdate("ip");
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
public void onPause() {
|
|
terminateService();
|
|
|
|
super.onPause();
|
|
}
|
|
|
|
@Override
|
|
protected void onStart() {
|
|
super.onStart();
|
|
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
|
|
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
|
|
}
|
|
|
|
RitoWebPlayerInterface ritoWebPlayerInterface;
|
|
RitoWebSystemInterface ritoWebSystemInterface;
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
|
|
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
|
|
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
|
|
|
|
setContentView(R.layout.activity_main);
|
|
|
|
mChannelOsdView = findViewById(R.id.textViewChannelOsd);
|
|
mChannelOsdImageView = findViewById(R.id.imageViewChannelOsd);
|
|
mImageViewBlack = findViewById(R.id.imageViewBlack);
|
|
mProgressBar = findViewById(R.id.progressBar);
|
|
|
|
mCarCastTitleView = findViewById(R.id.textViewCarcast);
|
|
|
|
mJsonResult = null;
|
|
mJsonIpSchedule = null;
|
|
mJsonFileSchedule = null;
|
|
INSTANCE = this;
|
|
mManagerActMode = MANAGER_ACTION_MODE_STANDBY;
|
|
|
|
//SystemUtil.logStart();
|
|
|
|
mIsDeviceOSIC10 = SystemUtil.property_get("rito.device.type").equalsIgnoreCase("osic10");
|
|
if(!mIsDeviceOSIC10) {
|
|
ImageView imgView = findViewById(R.id.imageViewWait);
|
|
imgView.setImageResource(R.drawable.no_broadcast);
|
|
}
|
|
|
|
mSDCardPath = SystemUtil.getSDCardPath();
|
|
mEmmcSavePath = Environment.getExternalStorageDirectory().getPath() + "/osic";
|
|
|
|
|
|
// PRDownloaderConfig config = PRDownloaderConfig.newBuilder()
|
|
// .setReadTimeout(30_000)
|
|
// .setConnectTimeout(30_000)
|
|
// .build();
|
|
// PRDownloader.initialize(getApplicationContext(), config);
|
|
|
|
mTickerManager = new TickerManager(this, (TextView)findViewById(R.id.textViewTicker));
|
|
mVfdManager = new VfdManager();
|
|
mVfdManager.start();
|
|
|
|
mSystemManager = new SystemManager();
|
|
//mSystemManager.initialize();
|
|
//mSystemManager.activateCpuFan(true);
|
|
mSystemManager.start();
|
|
|
|
String fancontrol = getConfigValue("fancontrol");
|
|
if(!fancontrol.equals("0")) {
|
|
mCoolerManager = new CoolerManager();
|
|
mCoolerManager.initialize();
|
|
mCoolerManager.start();
|
|
} else {
|
|
mCoolerManager = new CoolerManager();
|
|
mCoolerManager.initialize();
|
|
mCoolerManager.activateCpuFan(false);
|
|
}
|
|
|
|
mFileDownloader = new FileDownloader(this);
|
|
mFileDownloader.start();
|
|
|
|
|
|
int minBufferSize = AudioTrack.getMinBufferSize(EBCAST_SAMPLE_RATE, EBCAST_CHANNEL_CONFIG, EBCAST_AUDIO_FORMAT);
|
|
mAudioTrack = new AudioTrack(
|
|
AudioManager.STREAM_MUSIC,
|
|
EBCAST_SAMPLE_RATE,
|
|
EBCAST_CHANNEL_CONFIG,
|
|
EBCAST_AUDIO_FORMAT,
|
|
minBufferSize,
|
|
AudioTrack.MODE_STREAM
|
|
);
|
|
mAudioTrack.play();
|
|
// mTTSPlayer = new AudioFilePlayer();
|
|
// mTTSPlayer.setDownloadPath("http://192.168.1.60/test.mp3");
|
|
// mTTSPlayer.setPlayCount(3);
|
|
// mTTSPlayer.start();
|
|
/*mTTSPlayer.setDownloadPath("http://192.168.1.75/Factory.tgz");
|
|
mTTSPlayer.setDownloadPath("https://support.google.com/websearch/answer/1325808");
|
|
mTTSPlayer.start();*/
|
|
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_RITO) {
|
|
mPlayerNotify = new RitoPlayer.playerNotify() {
|
|
@Override
|
|
public void notify(int code, String info) {
|
|
Log.i("RitoMain", "NOTIFY Code : " + code);
|
|
if (code == RitoPlayer.PLAYER_NOTIFY_EOS) {
|
|
//mPlayer.stop();
|
|
/*SurfaceView view = findViewById(R.id.surfaceView);
|
|
mPlayer.mSurfaceView = view;
|
|
mPlayer.openUrl(0, "http://219.255.217.140/ext/contents/Your_wedding.ts");*/
|
|
}
|
|
}
|
|
};
|
|
|
|
if (mPlayer == null) {
|
|
mPlayer = new RitoPlayer(mPlayerNotify, 0);
|
|
mPlayer.init();
|
|
}
|
|
|
|
if (mAudioPlayer == null) {
|
|
mAudioPlayer = new RitoPlayer(mPlayerNotify, 1);
|
|
mAudioPlayer.init();
|
|
|
|
SystemUtil.setupAudioOut(1);
|
|
mAudioSubOut = new RitoPlayer.AudioOut() {
|
|
@Override
|
|
public void writeSamples(byte[] bytes, int i) {
|
|
if(mLastDacVolume > 0) {
|
|
SystemUtil.adjustDataVolume(bytes, i, mLastDacVolume);
|
|
//Log.i(TAG, "AudioPlayer AudioOut " + i + " bytes...");
|
|
SystemUtil.writeAudioOut(bytes, i);
|
|
}
|
|
}
|
|
};
|
|
|
|
mAudioPlayer.setAudioOut(mAudioSubOut);
|
|
mAudioPlayer.setAudioDirection(RitoPlayer.AUDIO_OUT_DIRECTION_AOUT);
|
|
//mAudioPlayer.openUrl(1,"http://211.204.122.90/ext/contents/akdong.mp3");
|
|
}
|
|
|
|
// SurfaceView view = findViewById(R.id.playerView);
|
|
// mPlayer.mSurfaceView = view;
|
|
|
|
mTexturePlayView = findViewById(R.id.texturePlayView);
|
|
mTexturePlayView.setSurfaceTextureListener(this);
|
|
mPlayer.mTextureView = mTexturePlayView;
|
|
mPlayer.openUrl(0,"udp://127.0.0.1:5000");
|
|
|
|
//mPlayer.openUrl(0,"http://211.204.122.90/ext/contents/IU.mp4");
|
|
/*setWaitViewVisibility(false);
|
|
mPlayer.openUrl(0,"http://219.255.217.140/ext/contents/IU.mp4");*/
|
|
//mPlayer.openUrl(0,"rtsp://gookmin.iptime.org:17100/Camera19");
|
|
} else if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
mSurface = findViewById(R.id.playerView);
|
|
holder = mSurface.getHolder();
|
|
|
|
mTexturePlayView = findViewById(R.id.texturePlayView);
|
|
mTexturePlayView.setSurfaceTextureListener(this);
|
|
//mTexturePlayView.setVisibility(View.VISIBLE);
|
|
|
|
String vlcMaxVolume = SystemUtil.property_get("sys.rito.volup.max");
|
|
if(vlcMaxVolume.length() > 0) {
|
|
mVlcMaxVolume = Integer.parseInt(vlcMaxVolume);
|
|
} else {
|
|
mVlcMaxVolume = 100;
|
|
}
|
|
|
|
//createPlayer("rtsp://gookmin.iptime.org:17100/Camera19");
|
|
if(USING_PLAYER_VIEW_TYPE == PLAYER_VIEW_TYPE_SURFACE_VIEW) {
|
|
createPlayer(null);
|
|
} else {
|
|
mSurface.setVisibility(View.INVISIBLE);
|
|
}
|
|
|
|
SystemUtil.setupAudioOut(1);
|
|
mAudioSubOut = new RitoPlayer.AudioOut() {
|
|
@Override
|
|
public void writeSamples(byte[] bytes, int i) {
|
|
if(mLastDacVolume > 0) {
|
|
SystemUtil.adjustDataVolume(bytes, i, mLastDacVolume);
|
|
SystemUtil.writeAudioOut(bytes, i);
|
|
}
|
|
}
|
|
};
|
|
|
|
mPlayerNotify = new RitoPlayer.playerNotify() {
|
|
@Override
|
|
public void notify(int code, String info) {
|
|
Log.i("RitoNotify", "NOTIFY Code : " + code);
|
|
if (code == RitoPlayer.PLAYER_NOTIFY_EOS) {
|
|
mIsRitoPlayerOver = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
if (mPlayer == null) {
|
|
mPlayer = new RitoPlayer(mPlayerNotify);
|
|
mPlayer.init();
|
|
mPlayer.setAudioOut(mAudioSubOut);
|
|
mPlayer.setAudioDirection(RitoPlayer.AUDIO_OUT_DIRECTION_AOUT);
|
|
//mPlayer.openUrl(0,"http://219.255.217.140/ext/contents/akdong.mp3");
|
|
}
|
|
|
|
//createPlayer("http://219.255.217.140/ext/contents/IU.mp4");
|
|
//createPlayer("udp://@:1234");
|
|
//createPlayer("udp://@:5000");
|
|
//createPlayer("http://172.16.40.146/20211118044730.ts");
|
|
//createPlayer("http://192.168.1.20/20211118044730.ts");
|
|
//createPlayer("udp://@234.6.7.8:5000");
|
|
|
|
}
|
|
setTTSViewVisibility(false);
|
|
setWaitViewVisibility(true);
|
|
//setWaitViewVisibility(false);
|
|
|
|
mExoPlayer = new ExoPlayer.Builder(MainActivity.INSTANCE).build();
|
|
mExoPlayer.addListener(new Player.Listener() {
|
|
@Override
|
|
public void onTimelineChanged(
|
|
Timeline timeline, @Player.TimelineChangeReason int reason) {
|
|
Object manifest = mExoPlayer.getCurrentManifest();
|
|
if (manifest != null) {
|
|
HlsManifest hlsManifest = (HlsManifest) manifest;
|
|
// Do something with the manifest.
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPlayerError(PlaybackException error) {
|
|
// 오류 처리
|
|
switch (error.errorCode) {
|
|
case PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED:
|
|
// 네트워크 연결 오류 처리
|
|
Log.e("ExoPlayer", "Network connection error: " + error.getMessage());
|
|
break;
|
|
|
|
case PlaybackException.ERROR_CODE_DECODING_FAILED:
|
|
// 디코딩 오류 처리
|
|
Log.e("ExoPlayer", "Decoding error: " + error.getMessage());
|
|
break;
|
|
|
|
default:
|
|
// 그 외의 오류 처리
|
|
Log.e("ExoPlayer", "Playback error: " + error.getMessage());
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onPlaybackStateChanged(int playbackState) {
|
|
if (playbackState == Player.STATE_ENDED) {
|
|
// 재생 완료 이벤트 처리
|
|
|
|
}
|
|
}
|
|
});
|
|
|
|
mWardId = getConfigValue("ward_id");
|
|
mEbcastMqttIp = getConfigValue("ebcast_ip");
|
|
String app_mode = getConfigValue("app_mode");
|
|
SystemUtil.APP_MODE = app_mode;
|
|
if(mIsDeviceOSIC10) {
|
|
if (SystemUtil.APP_MODE.equals("active")) { // Browser Mode 인 경우
|
|
setWaitViewVisibility(false);
|
|
WebView webview = (WebView) findViewById(R.id.webview);
|
|
webview.setWebViewClient(new RitoWebViewClient());
|
|
webview.getSettings().setJavaScriptEnabled(true);
|
|
|
|
ritoWebPlayerInterface = new RitoWebPlayerInterface();
|
|
ritoWebSystemInterface = new RitoWebSystemInterface();
|
|
webview.addJavascriptInterface(ritoWebSystemInterface, "system");
|
|
webview.addJavascriptInterface(ritoWebPlayerInterface, "player");
|
|
String value = SystemUtil.getConfigValue("svraddr");
|
|
//setWebViewUrl("http://" + value + "/stbpage/");
|
|
setWebViewUrl("http://" + value + "/stbpage/osic10.php"); // modified by ritoseo - 2023-05-21
|
|
setWebViewVisibility(true);
|
|
setWebViewLoadingVisibility(true);
|
|
}
|
|
}
|
|
|
|
if(mSDCardPath != null) {
|
|
mSDSavePath = mSDCardPath + "/osic";
|
|
File directory = new File(mSDSavePath);
|
|
if(!directory.exists())
|
|
directory.mkdir();
|
|
}
|
|
|
|
if(mJsonScheduler == null) {
|
|
mJsonScheduler = new JsonScheduler();
|
|
mJsonScheduler.start();
|
|
}
|
|
|
|
if(mDacScheduler == null) {
|
|
mDacScheduler = new DacScheduler();
|
|
mDacScheduler.start();
|
|
}
|
|
|
|
doStoredScheduleUpdate("ip");
|
|
doStoredScheduleUpdate("file");
|
|
|
|
// Log.w("RITO", "mJsonIpSchedule : " + mJsonIpSchedule);
|
|
// Log.w("RITO", "mJsonFileSchedule : " + mJsonFileSchedule);
|
|
|
|
String versionString = SystemUtil.getVersionInfo(this);
|
|
nativeInit(versionString);
|
|
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
// try {
|
|
// sleep(2000);
|
|
// } catch (InterruptedException e) {
|
|
// }
|
|
//
|
|
// String msgType = "general";
|
|
// AudioFilePlayer chimePlayer = new AudioFilePlayer();
|
|
// chimePlayer.setPlayMode("asset");
|
|
// if(msgType.equalsIgnoreCase("fire")) {
|
|
// chimePlayer.setPlayTarget("fire");
|
|
// } else if(msgType.equalsIgnoreCase("emergency")) {
|
|
// chimePlayer.setPlayTarget("emergency");
|
|
// } else if(msgType.equalsIgnoreCase("rescue")) {
|
|
// chimePlayer.setPlayTarget("rescue");
|
|
// } else {
|
|
// chimePlayer.setPlayTarget("general");
|
|
// }
|
|
// chimePlayer.start();
|
|
|
|
if(mEbcastMqttIp == null || mEbcastMqttIp.length() == 0)
|
|
return;
|
|
|
|
Random random = new Random();
|
|
String macAddr = SystemUtil.property_get("rito.board.mac");
|
|
Log.w(TAG, "Mqtt Address = " + "tcp://" + mEbcastMqttIp + ":1883");
|
|
while (true)
|
|
{
|
|
try {
|
|
if(mqttAndroidClient == null) {
|
|
MqttConnectOptions connectOptions;
|
|
|
|
//mqttAndroidClient = new MqttAndroidClient(MainActivity.INSTANCE.getApplicationContext(), "tcp://" + mEbcastMqttIp + ":1883", macAddr + random.nextInt());
|
|
mqttAndroidClient = new MqttAndroidClient(MainActivity.INSTANCE.getApplicationContext(), "tcp://" + mEbcastMqttIp + ":1883", macAddr + random.nextInt());
|
|
|
|
if(mqttAndroidClient != null) {
|
|
try {
|
|
connectOptions = new MqttConnectOptions();
|
|
// connectOptions.setAutomaticReconnect(true);
|
|
// connectOptions.setCleanSession(true);
|
|
connectOptions.setAutomaticReconnect(false);
|
|
connectOptions.setCleanSession(true);
|
|
connectOptions.setKeepAliveInterval(30);
|
|
|
|
mqttAndroidClient.setCallback(new MqttCallback() {
|
|
@Override
|
|
public void connectionLost(Throwable cause) {
|
|
// 연결이 끊겼을 때 실행
|
|
Log.d("MQTT","Connection lost: " + cause.getMessage());
|
|
if(mqttAndroidClient != null) {
|
|
mqttAndroidClient.close();
|
|
}
|
|
mqttAndroidClient = null;
|
|
}
|
|
|
|
@Override
|
|
public void messageArrived(String topic, MqttMessage message) throws Exception {
|
|
// 메시지가 도착했을 때 실행
|
|
System.out.println("Message arrived from topic " + topic + ": " + new String(message.getPayload()));
|
|
}
|
|
|
|
@Override
|
|
public void deliveryComplete(IMqttDeliveryToken token) {
|
|
// 메시지 전송이 완료되었을 때 실행
|
|
//System.out.println("Delivery complete");
|
|
}
|
|
});
|
|
|
|
mqttAndroidClient.connect(connectOptions, null, new IMqttActionListener() {
|
|
@Override
|
|
public void onSuccess(IMqttToken asyncActionToken) {
|
|
// 연결 성공
|
|
Log.d("MQTT", "Connected");
|
|
try {
|
|
mqttAndroidClient.subscribe("ebcast/notify/#", 1, new IMqttMessageListener() {
|
|
public void messageArrived(String topic, MqttMessage message) throws Exception {
|
|
String msgValue = message.toString();
|
|
Log.d("MQTT", "[RECV] <" + topic + "> " + msgValue);
|
|
if(topic.equalsIgnoreCase("ebcast/notify/screen")) {
|
|
JSONObject topObject = new JSONObject(msgValue);
|
|
String wardList = topObject.getString("wardList");
|
|
String dsrSeq = topObject.getString("dsrSeq");
|
|
String msgType = topObject.getString("msgType");
|
|
String msgDsrClass = topObject.getString("msgDsrClass");
|
|
String msgDsrSize = topObject.getString("msgDsrSize");
|
|
String msgDatetime = topObject.getString("msgDatetime");
|
|
String msgAddressDoro = topObject.getString("msgAddressDoro");
|
|
String msgAddressJibun = topObject.getString("msgAddressJibun");
|
|
String msgDesc = topObject.getString("msgDesc");
|
|
String msgVehicle = topObject.getString("msgVehicle");
|
|
Log.d("MQTT", "mWardId : " + MainActivity.INSTANCE.mWardId);
|
|
Log.d("MQTT", msgType + ", " + msgDsrClass + ", " + msgDsrSize);
|
|
if(wardList.contains(MainActivity.INSTANCE.mWardId)) {
|
|
mDsrSeq = dsrSeq;
|
|
handleNotifyScreenOrder(msgType, msgDsrClass, msgDsrSize, msgDatetime, msgAddressDoro, msgAddressJibun, msgDesc, msgVehicle);
|
|
|
|
final String assetPath;
|
|
if(msgType.equalsIgnoreCase("fire")) {
|
|
assetPath = "file:///android_asset/fire.wav";
|
|
} else if(msgType.equalsIgnoreCase("emergency")) {
|
|
assetPath = "file:///android_asset/emergency.wav";
|
|
} else if(msgType.equalsIgnoreCase("rescue")) {
|
|
assetPath = "file:///android_asset/rescue.wav";
|
|
} else {
|
|
assetPath = "file:///android_asset/general.wav";
|
|
}
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
MediaSource mediaSource = buildMediaSource(assetPath);
|
|
//mExoPlayer.setMediaItem(mediaSource);
|
|
mExoPlayer.setMediaSource(mediaSource);
|
|
mExoPlayer.prepare();
|
|
mExoPlayer.play();
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
|
|
// Notify Screen Chime
|
|
// AudioFilePlayer chimePlayer = new AudioFilePlayer();
|
|
// chimePlayer.setPlayMode("asset");
|
|
// if(msgType.equalsIgnoreCase("fire")) {
|
|
// chimePlayer.setPlayTarget("fire");
|
|
// } else if(msgType.equalsIgnoreCase("emergency")) {
|
|
// chimePlayer.setPlayTarget("emergency");
|
|
// } else if(msgType.equalsIgnoreCase("rescue")) {
|
|
// chimePlayer.setPlayTarget("rescue");
|
|
// } else {
|
|
// chimePlayer.setPlayTarget("general");
|
|
// }
|
|
// chimePlayer.start();
|
|
|
|
|
|
try {
|
|
JSONObject notiObject = new JSONObject();
|
|
notiObject.put("status", "command-receive");
|
|
notiObject.put("ward_id", mWardId);
|
|
notiObject.put("dsr_seq", mDsrSeq);
|
|
|
|
sendMqttMsg("ebcast/device/notify", notiObject.toString());
|
|
} catch(Exception e) {
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
mqttAndroidClient.subscribe("ebcast/client/#", 1, new IMqttMessageListener() {
|
|
@Override
|
|
public void messageArrived(String topic, MqttMessage message) throws Exception {
|
|
//Log.d("MQTT", "[RECV] <" + topic + "> " + message.getPayload().length + " Bytes...");
|
|
if(mDsrSeq != null && mDsrSeq.length() > 0) {
|
|
if (topic.startsWith("ebcast/client/cast/" + mDsrSeq)) {
|
|
byte[] buffer = message.getPayload();
|
|
int ret = mAudioTrack.write(buffer, 0, buffer.length);
|
|
Log.d("MQTT", "[AUDIO WRITE] " + ret);
|
|
long curTime = SystemClock.uptimeMillis();
|
|
|
|
if(mCastReceivedNotifyDsrSeq == null || !mCastReceivedNotifyDsrSeq.equals(mDsrSeq) || curTime - mDsrCastReceivedTime > 1200) {
|
|
mCastReceivedNotifyDsrSeq = mDsrSeq;
|
|
|
|
try {
|
|
JSONObject notiObject = new JSONObject();
|
|
notiObject.put("status", "cast-receive");
|
|
notiObject.put("ward_id", mWardId);
|
|
notiObject.put("dsr_seq", mDsrSeq);
|
|
|
|
sendMqttMsg("ebcast/device/notify", notiObject.toString());
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
|
|
mDsrCastReceivedTime = curTime;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
} catch (MqttException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
|
|
// 연결 실패
|
|
Log.e("MQTT", "Connection failed: " + exception.getMessage(), exception);
|
|
try {
|
|
Thread.sleep(5000);
|
|
if(mqttAndroidClient != null) {
|
|
mqttAndroidClient.close();
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
mqttAndroidClient = null;
|
|
|
|
|
|
}
|
|
});
|
|
|
|
|
|
} catch (MqttException e) {
|
|
mqttAndroidClient.close();
|
|
mqttAndroidClient = null;
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
Thread.sleep(500);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}.start();
|
|
|
|
// new Thread() {
|
|
// @Override
|
|
// public void run() {
|
|
// while(true) {
|
|
// File delFile = new File("/mnt/obb/fire");
|
|
// if(delFile.exists()) {
|
|
// delFile.delete();
|
|
//
|
|
// handleNotifyScreenOrder("fire",
|
|
// "주택화재",
|
|
// "3차출동",
|
|
// "2021-10-27 01:33:24",
|
|
// "서울특별시 구로구 디지털로 1113",
|
|
// "서울특별시 구로구 디지털로 11번지",
|
|
// "보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "진압차|1차|2차|3차|4차|5차");
|
|
// }
|
|
//
|
|
// delFile = new File("/mnt/obb/rescue");
|
|
// if(delFile.exists()) {
|
|
// delFile.delete();
|
|
//
|
|
// handleNotifyScreenOrder("rescue",
|
|
// "주택구조",
|
|
// "1차출동",
|
|
// "2020-10-27 01:33:24",
|
|
// "김포시 고촌읍 고촌로 13",
|
|
// "김포시 고촌읍 334번지",
|
|
// "입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "탑차|구급차|진압차|1차|2차|3차|4차|5차");
|
|
// }
|
|
//
|
|
// try {
|
|
// sleep(100);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// }
|
|
// }
|
|
// }.start();
|
|
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
sleep(300);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
// handleNotifyScreenOrder("rescue",
|
|
// "자살",
|
|
// "1차출동",
|
|
// "2024-01-04 21:18:00",
|
|
// "전라남도 보성군 우암길 4 ",
|
|
// "전라남도 보성군 회천면 율포리 315-3 ",
|
|
// "[요청기관] 전남지방경찰청 [접수일시] 2024-01-04 21:15:45\n" +
|
|
// "[재난종별] 기타경찰업무 [접수/요청자명]박대식/김원일-\n" +
|
|
// "[재난위치] (지)전라남도 보성군 회천면 율포리(회천면 ) 315-3 (경위도) 34.67045, 127.0868\n" +
|
|
// "[신고내용] 조카가 자살한다고 하고 전화를 끊었다며 / 요구조자 조카는 화순에서 거주 중 / [제3자 위치추적 정보][신고정보]1.성명 : 임승환 (남자, 삼촌)2.연락처 : 010-9887-64683.기타특이사항 : 없음[요구조자]1.성명 : 나현종 (남자, 50대)2.연락처 : 010-3753-48983.구조대상구분 : 자살기도 [위험상황]1. 상세상황 : 정보없음2. 신고자의 인지경위 : 정보없음[위치추적결과]1. 대상정보 : 2024.01.04 21:03:37 / CELL방식2. 대상주소 : 전라남도 보성군 회천면 율포리3. 대상관할 : 전남청 보성서 회천파출소 /이첩시도청 : 광주청 /이첩유형 : 공조 /이첩일자 : 2024-01-04 /이첩사건번호 : 1247 이첩사유 : 요구조자 위치값 : 전라남도 보성군 회천면 군농리(회천면 ) 1111-16 접수경로(112)",
|
|
// "회천구급/A/|회천중형/A/벌/");
|
|
|
|
|
|
//handleNotifyScreenOrder("rescue", "2020-10-27 01:33:24", "김포시 고촌읍 334번지", "입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.", "탑차|구급차|진압차|1차|2차|3차|4차|5차");
|
|
// handleNotifyScreenOrder("rescue",
|
|
// "주택구조",
|
|
// "1차출동",
|
|
// "2020-10-27 01:33:24",
|
|
// "김포시 고촌읍 고촌로 13",
|
|
// "김포시 고촌읍 334번지",
|
|
// "입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "탑차|구급차|진압차|1차|2차|3차|4차|5차");
|
|
//
|
|
// try {
|
|
// sleep(5000);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
//
|
|
// handleNotifyScreenOrder("fire",
|
|
// "주택화재",
|
|
// "3차출동",
|
|
// "2021-10-27 01:33:24",
|
|
// "서울특별시 구로구 디지털로 1113",
|
|
// "서울특별시 구로구 디지털로 11번지",
|
|
// "보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "진압차|1차|2차|3차|4차|5차");
|
|
//
|
|
// try {
|
|
// sleep(5000);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
//
|
|
// handleNotifyScreenOrder("rescue",
|
|
// "주택화재",
|
|
// "2차출동",
|
|
// "2021-10-27 01:33:24",
|
|
// "김포시 고촌읍 고촌로 13",
|
|
// "김포시 고촌읍 334번지",
|
|
// "입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "탑차|구급차|진압차|1차|2차|3차|4차|5차");
|
|
//
|
|
//
|
|
// for(int i = 0;i < 100;i++) {
|
|
// try {
|
|
// sleep(31000);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
//
|
|
// handleNotifyScreenOrder("rescue",
|
|
// "주택화재",
|
|
// "2차출동" + i,
|
|
// "2021-10-27 01:33:24",
|
|
// "김포시 고촌읍 고촌로 13",
|
|
// "김포시 고촌읍 334번지",
|
|
// "입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
// "탑차|구급차|진압차|1차|2차|3차|4차|5차");
|
|
// }
|
|
}
|
|
}.start();
|
|
|
|
//
|
|
|
|
/*mTickerManager.setupTicker("입덧은 임신 중에 느끼는 구역 및 구토 증상으로, 주로 임신 초기에 발생한다. 보통 임신 5~6주 정도에 시작해 9~10주에 가장 심하며, 대부분 16~18주면 사라지지만 그 이상 지속되는 경우도 있다.",
|
|
new Rect(0, 500, 1920, 600),
|
|
0xFFFFFF, 0x000000, 2, 200);
|
|
mTickerManager.renderTicker();*/
|
|
|
|
/*TickerView tickerView = findViewById(R.id.tickerView);
|
|
if(tickerView != null) {
|
|
tickerView.setupTicker("테스트 텍스트 입니다.", new Rect(0, 900, 1920, 1080), 0x000000, 0xFFFFFF);
|
|
tickerView.renderTicker();
|
|
}*/
|
|
|
|
/*final TextView tv = findViewById(R.id.textViewTicker);
|
|
Paint paint = new Paint();
|
|
paint.setTextSize(tv.getTextSize());
|
|
float spaceWidth = paint.measureText(" ");
|
|
float width = tv.getLayoutParams().width;
|
|
int dupCount = (int)(width / spaceWidth) + 1;
|
|
Log.e(TAG, String.format("spaceWidth : %2.2f, width : %2.2f, dupCount : %d", spaceWidth, width, dupCount));
|
|
String curText = "";
|
|
for(int i = 0;i < dupCount;i++)
|
|
curText += " ";
|
|
curText += tv.getText().toString();
|
|
tv.setText(curText);
|
|
//tv.setMarqueeRepeatLimit(-1);
|
|
tv.setMarqueeRepeatLimit(1);
|
|
tv.setSelected(true);
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
sleep(1000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
tv.setMarqueeSpeed(400f);
|
|
|
|
while(true) {
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
if(tv.isMarqueeStopped()) {
|
|
Log.e(TAG, "MARQUEE IS COMPLETE!!!!");
|
|
tv.setAlpha(0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}.start();*/
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
sleep(300);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
//SystemUtil.playWaveFile("/mnt/obb/loststar.wav", 1);
|
|
|
|
// {
|
|
// mIsRitoPlayerOver = false;
|
|
// mPlayer.openUrl(0, "/system/media/upchimes.wav");
|
|
// while (!mIsRitoPlayerOver) {
|
|
// try {
|
|
// sleep(10);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// }
|
|
//
|
|
// int mProgress = 0;
|
|
// while (mProgress < 3)
|
|
// {
|
|
// int curProgress = mProgress;
|
|
// mIsRitoPlayerOver = false;
|
|
// mPlayer.openUrl(0, "/mnt/obb/tts.wav");
|
|
// while (!mIsRitoPlayerOver) {
|
|
// try {
|
|
// sleep(10);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// }
|
|
// mProgress++;
|
|
// }
|
|
//
|
|
// mIsRitoPlayerOver = false;
|
|
// mPlayer.openUrl(0, "/system/media/downchimes.wav");
|
|
// }
|
|
}
|
|
}.start();
|
|
}
|
|
|
|
/*protected void setMarqueeSpeed(TextView tv, float speed,
|
|
boolean speedIsMultiplier) {
|
|
try {
|
|
Field f;
|
|
if (tv instanceof AppCompatTextView) {
|
|
f = tv.getClass().getSuperclass().getDeclaredField("mMarquee");
|
|
} else {
|
|
f = tv.getClass().getDeclaredField("mMarquee");
|
|
}
|
|
f.setAccessible(true);
|
|
Object marquee = f.get(tv);
|
|
Log.e(TAG, "MARQUEE COME 0");
|
|
if (marquee != null) {
|
|
String scrollSpeedFieldName = "mScrollUnit";
|
|
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
|
|
scrollSpeedFieldName = "mPixelsPerSecond";
|
|
|
|
Field mf = marquee.getClass().getDeclaredField(scrollSpeedFieldName);
|
|
mf.setAccessible(true);
|
|
|
|
float newSpeed = speed;
|
|
if (speedIsMultiplier)
|
|
newSpeed = mf.getFloat(marquee) * speed;
|
|
|
|
mf.setFloat(marquee, newSpeed);
|
|
Log.e(TAG, "MARQUEE COME 1");
|
|
}
|
|
Log.e(TAG, "MARQUEE COME 2");
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}*/
|
|
|
|
public void runTestStream() {
|
|
Media m = new Media(mVLC, Uri.parse("rtsp://gookmin.iptime.org:17100/Camera19"));
|
|
mVlcPlayer.stop();
|
|
mVlcPlayer.setMedia(m);
|
|
mVlcPlayer.play();
|
|
}
|
|
|
|
private void createPlayer(String media) {
|
|
releasePlayer();
|
|
try {
|
|
// if (media.length() > 0) {
|
|
// Toast toast = Toast.makeText(this, media, Toast.LENGTH_LONG);
|
|
// toast.setGravity(Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL, 0,
|
|
// 0);
|
|
// toast.show();
|
|
// }
|
|
|
|
// Create LibVLC
|
|
// TODO: make this more robust, and sync with audio demo
|
|
ArrayList<String> options = new ArrayList<String>();
|
|
//options.add("--subsdec-encoding <encoding>");
|
|
options.add("--aout=opensles");
|
|
//options.add("--aout=android_audiotrack");
|
|
options.add("--audio-time-stretch"); // time stretching
|
|
//options.add("--no-audio-time-stretch");
|
|
options.add("-vvv"); // verbosity
|
|
options.add("--http-reconnect");
|
|
options.add("--rtsp-tcp");
|
|
if(mIsDeviceOSIC10) {
|
|
options.add("--audio-resampler");
|
|
//options.add("disable");
|
|
options.add("soxr");
|
|
//options.add("samplerate");
|
|
//options.add("--network-caching=" + 20000);
|
|
|
|
|
|
// options.add("--avcodec-skip-frame");
|
|
// options.add("2000000");
|
|
} else {
|
|
options.add("--network-caching=" + 100);
|
|
}
|
|
mVLC = new LibVLC(this, options);
|
|
holder.setKeepScreenOn(true);
|
|
|
|
// Create media player
|
|
mVlcPlayer = new org.videolan.libvlc.MediaPlayer(mVLC);
|
|
mVlcPlayer.setEventListener(mPlayerListener);
|
|
//mVlcPlayer.getMedia().setHWDecoderEnabled(true, true);
|
|
setMainPlayerVolume(0);
|
|
|
|
// Set up video output
|
|
final IVLCVout vout = mVlcPlayer.getVLCVout();
|
|
//vout.setVideoView(mSurface);
|
|
vout.setVideoView(mTexturePlayView);
|
|
//vout.setSubtitlesView(mSurfaceSubtitles);
|
|
vout.setWindowSize(1920, 1080);
|
|
vout.addCallback(this);
|
|
vout.attachViews();
|
|
|
|
//mMediaPlayer.setScale(1920f / 800f);
|
|
//mMediaPlayer.setAspectRatio(null);
|
|
mVlcPlayer.setAspectRatio("16:9");
|
|
mVlcPlayer.setScale(0);
|
|
|
|
AudioFilePlayer mutePlayer = new AudioFilePlayer();
|
|
mutePlayer.setPlayMode("asset");
|
|
mutePlayer.playAssetAudio("mute.wav");
|
|
mPlayer.openUrl(0, "/system/media/mute.wav");
|
|
|
|
// new Thread() {
|
|
// @Override
|
|
// public void run() {
|
|
// try {
|
|
// sleep(8000);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
//
|
|
// try {
|
|
// Media muteMedia = new Media(mVLC, getAssets().openFd("upchimes.wav"));
|
|
// mVlcPlayer.setMedia(muteMedia);
|
|
// mVlcPlayer.play();
|
|
// } catch(Exception e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// }
|
|
// }.start();
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
// AudioFilePlayer mutePlayer = new AudioFilePlayer();
|
|
// mutePlayer.setPlayMode("asset");
|
|
// mutePlayer.playAssetAudio("mute.wav");
|
|
// try {
|
|
// sleep(3000);
|
|
// } catch (InterruptedException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// mutePlayer.playAssetAudio("mute.wav");
|
|
}
|
|
}.start();
|
|
|
|
if(media != null && media.length() > 0) {
|
|
Media m = new Media(mVLC, Uri.parse(media));
|
|
mLastPlayUrl = media;
|
|
if(mIsDeviceOSIC10) {
|
|
m.addOption(":network-caching=" + 3000);
|
|
}
|
|
//m.addOption(":network-caching=" + 10000);
|
|
mVlcPlayer.setMedia(m);
|
|
mVLCMedia = m;
|
|
mVlcPlayer.play();
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
//Toast.makeText(this, "Error creating player!", Toast.LENGTH_LONG).show();
|
|
}
|
|
}
|
|
|
|
private void releasePlayer() {
|
|
if (mVLC == null)
|
|
return;
|
|
mVlcPlayer.stop();
|
|
final IVLCVout vout = mVlcPlayer.getVLCVout();
|
|
vout.removeCallback(this);
|
|
vout.detachViews();
|
|
//holder = null;
|
|
mVlcPlayer.release();
|
|
mVlcPlayer = null;
|
|
mVLC.release();
|
|
mVLC = null;
|
|
}
|
|
|
|
public class DacScheduler extends Thread {
|
|
private String STREAM_IO_FILE = "/mnt/obb/_audio_streaming";
|
|
private boolean mIsAlive = true;
|
|
private RandomAccessFile mPipe;
|
|
private byte[] buffer = new byte[4096];
|
|
|
|
public void terminate() {
|
|
mIsAlive = false;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
Log.w(TAG, "Start DAC Scheduler.......");
|
|
File streamFile = new File(STREAM_IO_FILE);
|
|
if(streamFile.exists()) {
|
|
streamFile.delete();
|
|
}
|
|
mIsAlive = true;
|
|
byte[] streamBuffer = new byte[8192 * 30];
|
|
byte[] muteBuffer = new byte[65536];
|
|
// for(int i = 0;i < muteBuffer.length;i++) {
|
|
// if(i % 2 == 0)
|
|
// muteBuffer[i] = 127;
|
|
// }
|
|
int accSize = 0;
|
|
int noDacCount = 0;
|
|
boolean streamActive = false;
|
|
//SystemUtil.setupAudioOut(1);
|
|
while(mIsAlive) {
|
|
if(streamFile.exists() && !mIsOnTTSPlaying) {
|
|
if(mPipe == null) {
|
|
try {
|
|
mPipe = new RandomAccessFile(STREAM_IO_FILE, "r");
|
|
} catch (FileNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
if(mPipe != null) {
|
|
try {
|
|
int size = mPipe.read(buffer);
|
|
//Log.w(TAG, "PIPE Recv : " + size);
|
|
if(size > 0) {
|
|
byte[] dupBuffer = new byte[size * 2];
|
|
for(int i = 0;i < size; i += 2) {
|
|
dupBuffer[i * 2] = buffer[i];
|
|
dupBuffer[i * 2 + 1] = buffer[i + 1];
|
|
dupBuffer[(i + 1) * 2] = buffer[i];
|
|
dupBuffer[(i + 1) * 2 + 1] = buffer[i + 1];
|
|
}
|
|
// System.arraycopy(dupBuffer, 0, streamBuffer, accSize, size * 2);
|
|
// accSize += size * 2;
|
|
|
|
//SystemUtil.writeAudioOut(buffer, size);
|
|
if(!streamActive) {
|
|
streamActive = true;
|
|
SystemUtil.writeAudioOut(muteBuffer, muteBuffer.length);
|
|
}
|
|
|
|
SystemUtil.adjustDataVolume(dupBuffer, size * 2, mLastDacVolume);
|
|
SystemUtil.writeAudioOut(dupBuffer, size * 2);
|
|
|
|
//Log.d(TAG, "AudioStreaming Write : " + size * 2);
|
|
// if(accSize >= 8192) {
|
|
// if(!streamActive) {
|
|
// streamActive = true;
|
|
// SystemUtil.writeAudioOut(muteBuffer, muteBuffer.length);
|
|
// }
|
|
// SystemUtil.writeAudioOut(streamBuffer, accSize);
|
|
// Log.d(TAG, "AudioStreaming Write : " + accSize);
|
|
// accSize = 0;
|
|
// }
|
|
} else if(size <= 0) {
|
|
mPipe.close();
|
|
mPipe = null;
|
|
}
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
mPipe = null;
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
mPipe = null;
|
|
}
|
|
}
|
|
|
|
noDacCount = 0;
|
|
} else {
|
|
//Log.w(TAG, "NO Audio Streaming File...");
|
|
streamActive = false;
|
|
if(mPipe != null) {
|
|
try {
|
|
mPipe.close();
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
mPipe = null;
|
|
}
|
|
|
|
if(!mIsOnTTSPlaying) {
|
|
noDacCount++;
|
|
if(noDacCount > 10) {
|
|
noDacCount = 0;
|
|
// SystemUtil.writeAudioOut(muteBuffer, muteBuffer.length);
|
|
// Log.w(TAG, "Write DAC Mute Sound...");
|
|
}
|
|
}
|
|
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
|
|
try {
|
|
sleep(1);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setChannelOsdVisibility(final boolean show, final String title) {
|
|
if(show) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mChannelOsdImageView.setVisibility(View.VISIBLE);
|
|
|
|
mChannelOsdView.setText(title);
|
|
mChannelOsdView.setVisibility(View.VISIBLE);
|
|
mProgressBar.setVisibility(View.VISIBLE);
|
|
}
|
|
});
|
|
} else {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mChannelOsdImageView.setVisibility(View.INVISIBLE);
|
|
mChannelOsdView.setVisibility(View.INVISIBLE);
|
|
mProgressBar.setVisibility(View.INVISIBLE);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public void setAlertVisibility(final boolean show, final String msg) {
|
|
if(show) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
TextView alertView = findViewById(R.id.textViewAlert);
|
|
alertView.setText(msg);
|
|
|
|
FrameLayout layout = findViewById(R.id.layoutAlert);
|
|
layout.setVisibility(View.VISIBLE);
|
|
}
|
|
});
|
|
} else {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
FrameLayout layout = findViewById(R.id.layoutAlert);
|
|
layout.setVisibility(View.INVISIBLE);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public void setCarcastTitleVisibility(final boolean show, final String title) {
|
|
if(show) {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mCarCastTitleView.setText(title);
|
|
mCarCastTitleView.setVisibility(View.VISIBLE);
|
|
}
|
|
});
|
|
} else {
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mCarCastTitleView.setVisibility(View.INVISIBLE);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public class JsonScheduler extends Thread {
|
|
Object jsonLock = new Object();
|
|
boolean mIsAlive = false;
|
|
int mPlayIndex = 0;
|
|
int mLastPlayErrorIndex = -1;
|
|
int mRetryCount = 0;
|
|
int mPlayerState = org.videolan.libvlc.MediaPlayer.Event.EndReached;
|
|
int mVideoDecodedCount;
|
|
int mVideoStallCount;
|
|
int mAudioDecodedCount;
|
|
int mNoDataStreamCount = 0;
|
|
|
|
public void terminate() {
|
|
mIsAlive = false;
|
|
}
|
|
|
|
public void updateJsonResult(JsonResult result) {
|
|
setCarcastTitleVisibility(false, null);
|
|
|
|
synchronized (jsonLock) {
|
|
mJsonResult = result;
|
|
mPlayIndex = 0;
|
|
mRetryCount = 0;
|
|
|
|
try {
|
|
if(result != null && result.mType != null) {
|
|
SystemUtil.TraceLog("mJsonResult is changed to : " + result.mType);
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getRetryCount() {
|
|
int count;
|
|
synchronized (jsonLock) {
|
|
count = mRetryCount;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
public void setRetryCount(int count) {
|
|
synchronized (jsonLock) {
|
|
mRetryCount = count;
|
|
}
|
|
}
|
|
|
|
public void updateJsonTargetResult(String target, JsonResult result) {
|
|
synchronized (jsonLock) {
|
|
if(target.equalsIgnoreCase("ip")) {
|
|
mJsonIpSchedule = result;
|
|
} else if(target.equalsIgnoreCase("file")) {
|
|
mJsonFileSchedule = result;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void prepareJsonSchedule() {
|
|
if(mJsonResult != null) {
|
|
setTTSViewVisibility(false);
|
|
setWaitViewVisibility(false);
|
|
}
|
|
|
|
synchronized (jsonLock) {
|
|
mPlayIndex = 0;
|
|
|
|
if(mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST)) {
|
|
mPlayIndex = mJsonResult.mIpSelectedIndex;
|
|
Log.w(TAG, "PlayIndex is fixed to : " + mPlayIndex);
|
|
}
|
|
}
|
|
|
|
if(mVlcPlayer != null) {
|
|
mVlcPlayer.stop();
|
|
}
|
|
}
|
|
|
|
public void advancePlayNext(int direction) {
|
|
if(mIsOnNotifyMsg || mIsOnTTSPlaying)
|
|
return;
|
|
|
|
synchronized (jsonLock) {
|
|
mNoDataStreamCount = 0;
|
|
mRetryCount = 0;
|
|
if(mJsonResult != null) {
|
|
setCarcastTitleVisibility(false, null);
|
|
setWaitViewVisibility(false);
|
|
if(mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST)) {
|
|
mPlayIndex += direction;
|
|
|
|
// 파일 스케쥴이 있는 경우 IP방송에서 파일스케쥴로 변경
|
|
if(mPlayIndex < 0 || mPlayIndex >= mJsonResult.mIpCount) {
|
|
if(mJsonFileSchedule != null) {
|
|
mJsonResult = mJsonFileSchedule;
|
|
mPlayIndex = 0;
|
|
setMainPlayerVolume(0);
|
|
mVlcPlayer.stop();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(mPlayIndex < 0) {
|
|
mPlayIndex = mJsonResult.mIpCount - 1;
|
|
}
|
|
|
|
mPlayIndex %= mJsonResult.mIpCount;
|
|
|
|
// runOnUiThread(new Runnable() {
|
|
// @Override
|
|
// public void run() {
|
|
// mChannelOsdImageView.setVisibility(View.VISIBLE);
|
|
//
|
|
// //mImageViewBlack.setVisibility(View.VISIBLE);
|
|
// mChannelOsdView.setText(mJsonResult.mIpTitleList[mPlayIndex]);
|
|
// mChannelOsdView.setVisibility(View.VISIBLE);
|
|
// mProgressBar.setVisibility(View.VISIBLE);
|
|
// }
|
|
// });
|
|
|
|
setChannelOsdVisibility(true, mJsonResult.mIpTitleList[mPlayIndex]);
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
setMainPlayerVolume(0);
|
|
mVlcPlayer.stop();
|
|
}
|
|
}.start();
|
|
//mVlcPlayer.stop();
|
|
} else {
|
|
// 다른 스케쥴에서 IP방송스케쥴로 변경
|
|
if(mJsonIpSchedule != null) {
|
|
mJsonResult = mJsonIpSchedule;
|
|
mPlayIndex = 0;
|
|
if(direction < 0)
|
|
mPlayIndex = mJsonResult.mIpCount - 1;
|
|
advancePlayNext(0);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
if(mJsonIpSchedule != null) {
|
|
mJsonResult = mJsonIpSchedule;
|
|
mPlayIndex = 0;
|
|
if(direction < 0)
|
|
mPlayIndex = mJsonResult.mIpCount - 1;
|
|
|
|
if(mLastPlayErrorIndex >= 0) {
|
|
mPlayIndex = mLastPlayErrorIndex;
|
|
mLastPlayErrorIndex = -1;
|
|
mPlayIndex += direction;
|
|
if(mPlayIndex < 0) {
|
|
mPlayIndex = mJsonResult.mIpCount - 1;
|
|
}
|
|
|
|
mPlayIndex %= mJsonResult.mIpCount;
|
|
}
|
|
|
|
advancePlayNext(0);
|
|
return;
|
|
} else if(mJsonFileSchedule != null) {
|
|
mJsonResult = mJsonFileSchedule;
|
|
mPlayIndex = 0;
|
|
setMainPlayerVolume(0);
|
|
mVlcPlayer.stop();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isPlayReady() {
|
|
if(mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EndReached ||
|
|
mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EncounteredError ||
|
|
mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Stopped)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private void nextPlayWithUrl(String url) {
|
|
Media m = new Media(mVLC, Uri.parse(url));
|
|
mVlcPlayer.stop();
|
|
mLastPlayErrorIndex = -1;
|
|
mNoDataStreamCount = 0;
|
|
mLastPlayUrl = url;
|
|
mVlcPlayer.setMedia(m);
|
|
mVLCMedia = m;
|
|
mVlcPlayer.play();
|
|
if(mIsDeviceOSIC10) {
|
|
setMainPlayerVolume(0);
|
|
} else {
|
|
setMainPlayerVolume(mVlcMaxVolume);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
int reportCount = 0;
|
|
mIsAlive = true;
|
|
while(mIsAlive) {
|
|
if(SystemUtil.property_get("sys.rito.die").equals("1")) {
|
|
String hoho = null;
|
|
Log.w("LEN", "hoho : " + hoho.length());
|
|
}
|
|
|
|
if(mVlcPlayer != null) {
|
|
if (!mVlcPlayer.isPlaying() && isPlayReady()) {
|
|
mNoDataStreamCount = 0;
|
|
synchronized (jsonLock) {
|
|
if(mJsonResult != null) {
|
|
if(mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_CONTENTS)) {
|
|
int playIndex;
|
|
|
|
playIndex = mPlayIndex;
|
|
mPlayIndex++;
|
|
mPlayIndex %= mJsonResult.mFileCount;
|
|
|
|
Log.w(TAG, "Play FilePath : " + mSDSavePath + "/" + mJsonResult.mFilePathList[playIndex]);
|
|
nextPlayWithUrl("file://" + mSDSavePath + "/" + mJsonResult.mFilePathList[playIndex]);
|
|
} else if(mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_CARCAST)) {
|
|
mPlayIndex = 0;
|
|
mRetryCount++;
|
|
|
|
Log.w(TAG, "Play CarUrl : " + mJsonResult.mCarAddress);
|
|
if(mJsonResult.mCarStation != null && mJsonResult.mCarCar != null) {
|
|
String carTitle = " " + mJsonResult.mCarStation + "-" + mJsonResult.mCarCar;
|
|
setCarcastTitleVisibility(true, carTitle);
|
|
}
|
|
nextPlayWithUrl(mJsonResult.mCarAddress);
|
|
} else if(mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST)) {
|
|
mRetryCount++;
|
|
|
|
Log.w(TAG, "Play IpUrl : " + mJsonResult.mIpAddressList[mPlayIndex]);
|
|
nextPlayWithUrl(mJsonResult.mIpAddressList[mPlayIndex]);
|
|
}
|
|
} else {
|
|
SystemUtil.TraceLog("mJsonResult is NULL...");
|
|
}
|
|
}
|
|
} else {
|
|
SystemUtil.TraceLog("mVlcPlayer.isPlaying() : " + mVlcPlayer.isPlaying() + ", isPlayReady() :" + isPlayReady());
|
|
//IMedia media = mVlcPlayer.getMedia();
|
|
try {
|
|
if (mVLCMedia != null) {
|
|
IMedia.Stats stats = mVLCMedia.getStats();
|
|
if (stats != null) {
|
|
String info = String.format("[Media] VideoDecoded : %d, AudioDecoded : %d, InputBitrate : %1.4f mbps, demuxBitrate : %1.4f mbps",
|
|
stats.decodedVideo,
|
|
stats.decodedAudio,
|
|
stats.inputBitrate,
|
|
stats.demuxBitrate);
|
|
SystemUtil.TraceLog(SystemUtil.TRACE_LOG_LEVEL_2, info);
|
|
reportCount++;
|
|
if(reportCount >= 50) {
|
|
reportCount = 0;
|
|
Log.i(TAG, String.format("[Media] VideoLost : %d, AudioLost : %d", stats.lostPictures, stats.lostAbuffers));
|
|
}
|
|
|
|
if(!mIsDeviceOSIC10) { // 소방방송 모드
|
|
if(stats.inputBitrate > 0) {
|
|
mNoDataStreamCount = 0;
|
|
synchronized (jsonLock) {
|
|
if (mJsonResult != null) {
|
|
if (mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST)) {
|
|
if (mVideoDecodedCount == stats.decodedVideo) {
|
|
mVideoStallCount++;
|
|
if (mVideoStallCount > 20) {
|
|
mVideoStallCount = 0;
|
|
Log.w(TAG, "Catch Video Stalled on Live!! Try Replay [" + mJsonResult.mIpAddressList[mPlayIndex] + "]");
|
|
nextPlayWithUrl(mJsonResult.mIpAddressList[mPlayIndex]);
|
|
}
|
|
} else {
|
|
mVideoStallCount = 0;
|
|
mVideoDecodedCount = stats.decodedVideo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (mJsonResult != null) {
|
|
if (mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST) ||
|
|
mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_CARCAST)) {
|
|
mNoDataStreamCount++;
|
|
if (mNoDataStreamCount > 20) {
|
|
mNoDataStreamCount = 0;
|
|
mVlcPlayer.stop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else { // added by ritoseo - 2024-09-13
|
|
if(stats.demuxBitrate > 0) {
|
|
mNoDataStreamCount = 0;
|
|
if (mVideoDecodedCount == stats.decodedVideo) {
|
|
mVideoStallCount++;
|
|
if (mVideoStallCount > 20) {
|
|
mVideoStallCount = 0;
|
|
Log.w(TAG, "Catch Video Stalled on Live!! Player STOP!!!");
|
|
mVlcPlayer.stop();
|
|
}
|
|
} else {
|
|
mVideoStallCount = 0;
|
|
mVideoDecodedCount = stats.decodedVideo;
|
|
}
|
|
} else {
|
|
mNoDataStreamCount++;
|
|
if (mNoDataStreamCount > 20) {
|
|
Log.w(TAG, "Catch Stream is Stop on Live!! Player STOP!!!");
|
|
mNoDataStreamCount = 0;
|
|
mVlcPlayer.stop();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
sleep(200);
|
|
} catch (InterruptedException e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void handlePlayEvent() {
|
|
if(!mIsDeviceOSIC10) { // 소방방송 모드인 경우
|
|
try {
|
|
if (mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EndReached ||
|
|
mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Stopped ||
|
|
mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EncounteredError) {
|
|
|
|
if (mJsonResult != null && mJsonResult.mType != null) {
|
|
if (mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_CARCAST) ||
|
|
mJsonResult.mType.equalsIgnoreCase(MANAGER_JSON_ORDER_TYPE_PLAY_IPCAST)) {
|
|
int retryCount = mJsonScheduler.getRetryCount();
|
|
if (retryCount >= 2) {
|
|
Log.w(TAG, "스트림이 끊겨서 대기화면으로 전환합니다");
|
|
//setState("standby");
|
|
mJsonScheduler.mLastPlayErrorIndex = mJsonScheduler.mPlayIndex;
|
|
setWaitViewVisibility(true);
|
|
mJsonScheduler.updateJsonResult(null);
|
|
|
|
try {
|
|
AssetFileDescriptor afd = getAssets().openFd("blackground.png");
|
|
mVlcPlayer.play(afd);
|
|
} catch(Exception e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mIsOnNotifyMsg || mIsOnTTSPlaying)
|
|
return;
|
|
|
|
} catch(Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
} else { // OSIC10 모드인 경우
|
|
if (mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EndReached ||
|
|
mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Stopped ||
|
|
mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EncounteredError) {
|
|
if(mLastPlayUrl != null) {
|
|
int retryCount = mJsonScheduler.getRetryCount();
|
|
Log.w(TAG, "retryCount : " + retryCount);
|
|
if (retryCount == 2) {
|
|
if(!SystemUtil.APP_MODE.equals("active")) { // Browser Mode 아닌경우
|
|
setWaitViewVisibility(true);
|
|
setState("standby");
|
|
mVlcPlayer.stop();
|
|
mLastPlayUrl = null;
|
|
mJsonScheduler.setRetryCount(retryCount + 1);
|
|
}
|
|
} else if (retryCount < 2) {
|
|
if(!SystemUtil.APP_MODE.equals("active")) { // Browser Mode 아닌 경우
|
|
mJsonScheduler.setRetryCount(retryCount + 1);
|
|
}
|
|
//mVlcPlayer.stop();
|
|
if (mShouldStopPlay) {
|
|
mLastPlayUrl = null;
|
|
mShouldPlayUrl = null;
|
|
mShouldStopPlay = false;
|
|
}
|
|
|
|
if (mLastPlayUrl != null) {
|
|
Media m = new Media(mVLC, Uri.parse(mLastPlayUrl));
|
|
if(mIsDeviceOSIC10) {
|
|
setupVlcMediaOption(m);
|
|
}
|
|
mVlcPlayer.setMedia(m);
|
|
mVLCMedia = m;
|
|
mVlcPlayer.play();
|
|
}
|
|
}
|
|
} else {
|
|
Log.w(TAG, "mLastPlayUrl is null!!!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*************
|
|
* Events
|
|
*************/
|
|
|
|
private org.videolan.libvlc.MediaPlayer.EventListener mPlayerListener = new MyPlayerListener(this);
|
|
private static int mLastALossCount = 0;
|
|
private static int mLastVLossCount = 0;
|
|
private static long mLastALossCheckTime = 0;
|
|
private static long mBufferingStartTime = 0;
|
|
private static long mLastPositionChangedTime = 0;
|
|
|
|
private static class PacketLossCheck {
|
|
public long mLossTime;
|
|
public int mLossCount;
|
|
|
|
public PacketLossCheck(long time, int count) {
|
|
mLossCount = count;
|
|
mLossTime = time;
|
|
}
|
|
}
|
|
private static LinkedBlockingQueue<PacketLossCheck> mLossCheck = new LinkedBlockingQueue<>(10);
|
|
|
|
private static class MyPlayerListener implements org.videolan.libvlc.MediaPlayer.EventListener {
|
|
private WeakReference<MainActivity> mOwner;
|
|
private PlayerChecker mChecker;
|
|
|
|
private class PlayerChecker extends Thread {
|
|
boolean mIsAlive = true;
|
|
@Override
|
|
public void run() {
|
|
while(mIsAlive) {
|
|
long bufferingStartTime = mBufferingStartTime;
|
|
if(bufferingStartTime > 0) {
|
|
long curTime = SystemClock.uptimeMillis();
|
|
|
|
if(curTime - bufferingStartTime > 10 * 1000) { // 10 Seconds...
|
|
Log.w("RITO", "curTime - bufferingStartTime = " + (curTime - bufferingStartTime));
|
|
MainActivity player = mOwner.get();
|
|
mBufferingStartTime = curTime;
|
|
MainActivity.INSTANCE.setAlertVisibility(true, "입력 신호가 매우 약합니다.");
|
|
try {
|
|
sleep(2000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
MainActivity.INSTANCE.setAlertVisibility(false, "");
|
|
// player.mVlcPlayer.stop();
|
|
// if(MainActivity.INSTANCE.mChannelOsdImageView.getVisibility() == View.VISIBLE) {
|
|
// MainActivity.INSTANCE.setChannelOsdVisibility(false, "");
|
|
// }
|
|
|
|
}
|
|
}
|
|
|
|
/* Added by ritoseo - 2024-09-11 */
|
|
// MainActivity player = mOwner.get();
|
|
// String currentPlayUrl = player.mCurrentPlayUrl;
|
|
// if(currentPlayUrl != null) {
|
|
// if(currentPlayUrl.startsWith("udp://") || currentPlayUrl.startsWith("rtsp://")) {
|
|
// long curTime = SystemClock.uptimeMillis();
|
|
// if(mLastPositionChangedTime > 0 && curTime - mLastPositionChangedTime >= 4000) {
|
|
// Log.w("RITO", "####### Detect Playback Stalled!!! ######");
|
|
// player.mVlcPlayer.stop();
|
|
// }
|
|
// }
|
|
// }
|
|
/* ------------------------------ */
|
|
try {
|
|
sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void quit() {
|
|
mIsAlive = false;
|
|
}
|
|
}
|
|
|
|
public MyPlayerListener(MainActivity owner) {
|
|
mOwner = new WeakReference<MainActivity>(owner);
|
|
mChecker = new PlayerChecker();
|
|
mChecker.start();
|
|
}
|
|
|
|
@Override
|
|
public void onEvent(org.videolan.libvlc.MediaPlayer.Event event) {
|
|
MainActivity player = mOwner.get();
|
|
//Log.d(TAG, "Player EVENT");
|
|
switch(event.type) {
|
|
case org.videolan.libvlc.MediaPlayer.Event.EndReached:
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.EndReached;
|
|
player.mCurrentPlayUrl = null;
|
|
mBufferingStartTime = 0;
|
|
Log.d(TAG, "MediaPlayerEndReached");
|
|
//player.releasePlayer();
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.EncounteredError:
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.EncounteredError;
|
|
player.mCurrentPlayUrl = null;
|
|
mBufferingStartTime = 0;
|
|
Log.d(TAG, "Media Player Error, re-try");
|
|
//player.releasePlayer();
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.Playing:
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.Playing;
|
|
if(MainActivity.INSTANCE.mIsOnNotifyMsg || (MainActivity.INSTANCE.mIsOnTTSPlaying && !MainActivity.INSTANCE.mIsDeviceOSIC10) ||
|
|
MainActivity.INSTANCE.mIsDeviceOSIC10) {
|
|
MainActivity.INSTANCE.setMainPlayerVolume(0);
|
|
}
|
|
mLastALossCheckTime = SystemClock.uptimeMillis();
|
|
mLastALossCount = 0;
|
|
mLastVLossCount = 0;
|
|
Log.i(TAG, "RITO Playing...");
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.Buffering:
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.Buffering;
|
|
|
|
mBufferingStartTime = SystemClock.uptimeMillis();
|
|
if(MainActivity.INSTANCE.mIsDeviceOSIC10){
|
|
if (MainActivity.INSTANCE.mShouldPlayUrl != null) {
|
|
Log.i(TAG, "RITO Buffering... [" + player.mVlcPlayer.getMedia().getUri().toString() + "] <" + MainActivity.INSTANCE.mShouldPlayUrl + ">");
|
|
if(!MainActivity.INSTANCE.mShouldPlayUrl.equals(player.mVlcPlayer.getMedia().getUri().toString())) {
|
|
Log.w(TAG, "FORCE Change URL To Real URL [" + MainActivity.INSTANCE.mShouldPlayUrl + "]");
|
|
player.mVlcPlayer.play(MainActivity.INSTANCE.mShouldPlayUrl);
|
|
}
|
|
} else {
|
|
Log.i(TAG, "RITO Buffering... [" + player.mVlcPlayer.getMedia().getUri().toString() + "]");
|
|
}
|
|
} else {
|
|
Log.i(TAG, "RITO Buffering...");
|
|
}
|
|
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.Paused:
|
|
Log.i(TAG, "RITO Paused...");
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.Paused;
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.Stopped:
|
|
player.mJsonScheduler.mPlayerState = org.videolan.libvlc.MediaPlayer.Event.Stopped;
|
|
player.mCurrentPlayUrl = null;
|
|
Log.i(TAG, "RITO Play Stopped...");
|
|
player.handlePlayEvent();
|
|
mBufferingStartTime = 0;
|
|
mLastVLossCount = 0;
|
|
//player.runTestStream();
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.TimeChanged:
|
|
if(MainActivity.INSTANCE.mChannelOsdImageView.getVisibility() == View.VISIBLE) {
|
|
// MainActivity.INSTANCE.mChannelOsdImageView.setVisibility(View.INVISIBLE);
|
|
// MainActivity.INSTANCE.mChannelOsdView.setVisibility(View.INVISIBLE);
|
|
// MainActivity.INSTANCE.mProgressBar.setVisibility(View.INVISIBLE);
|
|
//MainActivity.INSTANCE.mImageViewBlack.setVisibility(View.INVISIBLE);
|
|
MainActivity.INSTANCE.setChannelOsdVisibility(false, "");
|
|
}
|
|
|
|
//Log.i(TAG, "RITO TimeChanged... : " + player.mVlcPlayer.getTime());
|
|
|
|
if(MainActivity.INSTANCE.mIsDeviceOSIC10) {
|
|
if (MainActivity.INSTANCE.mVlcVolume == 0) {
|
|
Log.i(TAG, "RITO Volume Changer : " + player.mVlcPlayer.getTime());
|
|
MainActivity.INSTANCE.setMainPlayerVolume(1);
|
|
new Thread() {
|
|
public void run() {
|
|
int delay = 1000;
|
|
String delayString = SystemUtil.property_get("sys.rito.volup.delay");
|
|
if(delayString != null && delayString.length() > 0) {
|
|
delay = Integer.parseInt(delayString);
|
|
}
|
|
Log.i(TAG, "RITO Volume Delay : " + delay);
|
|
try {
|
|
sleep(delay);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
for (int i = 1; i < INSTANCE.mVlcMaxVolume; i++) {
|
|
MainActivity.INSTANCE.setMainPlayerVolume(i);
|
|
try {
|
|
sleep(5);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}.start();
|
|
}
|
|
}
|
|
|
|
break;
|
|
case org.videolan.libvlc.MediaPlayer.Event.PositionChanged:
|
|
mBufferingStartTime = 0;
|
|
mLastPositionChangedTime = SystemClock.uptimeMillis();
|
|
player.mJsonScheduler.setRetryCount(0);
|
|
IMedia.Stats stats = player.mVlcPlayer.getMedia().getStats();
|
|
if(stats != null) {
|
|
SystemUtil.TraceLog(String.format("[Media Stat] VLoss : %d, ALoss : %d, Position : %2.1f", stats.lostPictures, stats.lostAbuffers, player.mVlcPlayer.getPosition()));
|
|
if(mLastVLossCount == 0 && stats.lostPictures > 0)
|
|
mLastVLossCount = stats.lostPictures;
|
|
|
|
if(stats.lostPictures > mLastVLossCount && mLastVLossCount > 0) {
|
|
mLastVLossCount = stats.lostPictures;
|
|
if(mLossCheck.size() > 0) {
|
|
PacketLossCheck first = mLossCheck.peek();
|
|
long timeGap = SystemClock.uptimeMillis() - first.mLossTime;
|
|
if(timeGap <= 5000) {
|
|
if(mLastVLossCount - first.mLossCount >= 3) {
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
MainActivity.INSTANCE.setAlertVisibility(true, "입력 신호가 약합니다.");
|
|
try {
|
|
sleep(2000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
MainActivity.INSTANCE.setAlertVisibility(false, "");
|
|
}
|
|
}.start();
|
|
}
|
|
|
|
if(mLossCheck.size() >= 8) {
|
|
mLossCheck.poll();
|
|
}
|
|
} else {
|
|
mLossCheck.poll();
|
|
}
|
|
}
|
|
try {
|
|
mLossCheck.put(new PacketLossCheck(SystemClock.uptimeMillis(), mLastVLossCount));
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
if(stats.lostAbuffers >= 10) {
|
|
String strUri = player.mVlcPlayer.getMedia().getUri().toString();
|
|
if(strUri.startsWith("udp://") || strUri.startsWith("rtsp://")) {
|
|
player.mVlcPlayer.play(player.mVlcPlayer.getMedia());
|
|
}
|
|
}
|
|
}
|
|
//Log.i(TAG, "RITO Position : " + player.mVlcPlayer.getPosition());
|
|
//Log.i(TAG, "RITO URI : " + player.mVlcPlayer.getMedia().getUri().toString());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private class RitoWebSystemInterface {
|
|
public RitoWebSystemInterface() {
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void canMenuAutoHide(int method) {
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void setOneshotMode(int method) {
|
|
}
|
|
|
|
|
|
@JavascriptInterface
|
|
public void test() {
|
|
}
|
|
}
|
|
|
|
private class RitoWebPlayerInterface {
|
|
class ChannelInfo {
|
|
int ch_no;
|
|
String url;
|
|
String title;
|
|
String screenOpt;
|
|
};
|
|
|
|
public int PLAYER_STATUS_QUIT = 0;
|
|
public int PLAYER_STATUS_PLAY = 1;
|
|
public int PLAYER_STATUS_PAUSE = 2;
|
|
public int PLAYER_STATUS_FASTFORWARD = 3;
|
|
public int PLAYER_STATUS_FASTBACKWARD = 4;
|
|
public int PLAYER_STATUS_INIT = 5;
|
|
|
|
int mViewPortWidth;
|
|
int mViewPortHeight;
|
|
public ArrayList<ChannelInfo> mChannelList;
|
|
public int mPlayChannelIndex;
|
|
AssetFileDescriptor mBlackAfd;
|
|
|
|
|
|
public RitoWebPlayerInterface() {
|
|
mViewPortWidth = 1280;
|
|
mViewPortHeight = 720;
|
|
mChannelList = new ArrayList<>();
|
|
|
|
try {
|
|
mBlackAfd = getAssets().openFd("blackground.png");
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void setViewPort(int width, int height) {
|
|
mViewPortWidth = width;
|
|
mViewPortHeight = height;
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void quit() {
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mVlcPlayer != null) {
|
|
//mVlcPlayer.stop();
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
//AssetFileDescriptor afd = getAssets().openFd("blackground.png");
|
|
// mVlcPlayer.pause();
|
|
// mVlcPlayer.detachViews();
|
|
// sleep(100);
|
|
// Canvas canvas = mTexturePlayView.lockCanvas();
|
|
// if(canvas != null) {
|
|
// canvas.drawRGB(0, 0, 0);
|
|
// mTexturePlayView.unlockCanvasAndPost(canvas);
|
|
// }
|
|
mVlcPlayer.stop();
|
|
sleep(100);
|
|
mVlcPlayer.play(mBlackAfd);
|
|
sleep(200);
|
|
|
|
// final IVLCVout vout = mVlcPlayer.getVLCVout();
|
|
// vout.setVideoView(mTexturePlayView);
|
|
// vout.setWindowSize(1920, 1080);
|
|
// vout.addCallback(MainActivity.INSTANCE);
|
|
// vout.attachViews();
|
|
|
|
mVlcPlayer.stop();
|
|
} catch(Exception e) {
|
|
}
|
|
|
|
}
|
|
}.start();
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void controlMethod(int method) {
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void setEventTarget(Object target) {
|
|
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public int getStatus() {
|
|
int status = PLAYER_STATUS_INIT;
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
if(mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Playing
|
|
|| mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Buffering) {
|
|
status = PLAYER_STATUS_PLAY;
|
|
} else if(mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EncounteredError
|
|
|| mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.EndReached
|
|
|| mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Stopped) {
|
|
status = PLAYER_STATUS_QUIT;
|
|
} else if(mJsonScheduler.mPlayerState == org.videolan.libvlc.MediaPlayer.Event.Paused) {
|
|
status = PLAYER_STATUS_PAUSE;
|
|
}
|
|
}
|
|
|
|
//Log.w(TAG, "getStatus() = " + status);
|
|
|
|
return status;
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void setPlayChannelList(String channelList, int startIdx) {
|
|
Log.w(TAG, "[setPlayChannelList] " + channelList + ", startIdx : " + startIdx);
|
|
mChannelList.clear();
|
|
String[] tokens = channelList.split("[\r\n]");
|
|
for(String token : tokens) {
|
|
//Log.w(TAG, "Token : " + token);
|
|
ChannelInfo info = new ChannelInfo();
|
|
String[] subTokens = token.split("\\^");
|
|
//Log.w(TAG, "SubTokenCount : " + subTokens.length);
|
|
if(subTokens[0] != null) { // Channel Number and URL
|
|
String[] babyToken = subTokens[0].split("=");
|
|
//Log.w(TAG, "babyToken[0] : " + babyToken[0]);
|
|
if(babyToken[0] != null) { // Channel No
|
|
if(babyToken[0].startsWith("ch")) {
|
|
info.ch_no = Integer.parseInt(babyToken[0].substring(2));
|
|
}
|
|
}
|
|
if(babyToken[1] != null) { // URL
|
|
//Log.w(TAG, "babyToken[1] : " + babyToken[1]);
|
|
info.url = babyToken[1];
|
|
if(info.url.contains("mc://")) {
|
|
info.url = info.url.replace("_", ":");
|
|
}
|
|
info.url = info.url.replace("mc://2", "udp://@2");
|
|
info.url = info.url.replace("mc://", "udp://");
|
|
|
|
info.url = info.url.replace("hsact://", "rtsp://");
|
|
}
|
|
}
|
|
|
|
if(subTokens.length >= 2 && subTokens[1] != null) { // Options
|
|
String[] babyToken = subTokens[1].split("\\|");
|
|
if(babyToken[0] != null) { // Misc Options..
|
|
|
|
}
|
|
if(babyToken.length >= 2 && babyToken[1] != null) { // Title
|
|
info.title = babyToken[1];
|
|
}
|
|
}
|
|
|
|
if(info != null) {
|
|
mChannelList.add(info);
|
|
}
|
|
}
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void runChannelList(int ch_no) {
|
|
Log.w(TAG, "runChannelList : " + ch_no);
|
|
MainActivity.INSTANCE.mShouldStopPlay = false;
|
|
if(USING_MAIN_PLAYER_LIBRARY_TYPE == PLAYER_LIBRARY_TYPE_VLC) {
|
|
for(int i = 0;i < mChannelList.size();i++) {
|
|
if(mChannelList.get(i).ch_no == ch_no) {
|
|
//final Media m = new Media(mVLC, Uri.parse(mChannelList.get(i).url));
|
|
final int index = i;
|
|
mPlayChannelIndex = i;
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
mVlcPlayer.stop();
|
|
Log.w(TAG, "runChannelList URL : " + mChannelList.get(index).url);
|
|
Media m = new Media(mVLC, Uri.parse(mChannelList.get(index).url));
|
|
if(mIsDeviceOSIC10) {
|
|
setupVlcMediaOption(m);
|
|
}
|
|
mVlcPlayer.setMedia(m);
|
|
mVLCMedia = m;
|
|
mLastPlayUrl = mChannelList.get(index).url;
|
|
mShouldPlayUrl = mLastPlayUrl;
|
|
mVlcPlayer.play();
|
|
//Log.w(TAG, "VLCPlayer.play() 1");
|
|
}
|
|
}.start();
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public int getPlayChannelIndex() {
|
|
return mPlayChannelIndex;
|
|
}
|
|
|
|
@JavascriptInterface
|
|
public void setScreenPosition(int left, int top, int width, int height) {
|
|
if(USING_PLAYER_VIEW_TYPE == PLAYER_VIEW_TYPE_TEXTURE_VIEW) {
|
|
final int x1 = left * 1920 / mViewPortWidth;
|
|
final int y1 = top * 1080 / mViewPortHeight;
|
|
final int width2 = width * 1920 / mViewPortWidth;
|
|
final int height2 = height * 1080 / mViewPortHeight;
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
TextureView view = findViewById(R.id.texturePlayView);
|
|
view.setX(x1);
|
|
view.setY(y1);
|
|
view.setLayoutParams(new FrameLayout.LayoutParams(width2, height2));
|
|
|
|
final IVLCVout vout = mVlcPlayer.getVLCVout();
|
|
vout.setWindowSize(width2, height2);
|
|
//mVlcPlayer.setAspectRatio(null);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
private class RitoWebViewClient extends WebViewClient {
|
|
@Override
|
|
public boolean shouldOverrideUrlLoading(WebView view, String url) {
|
|
// url 주소에 해당하는 웹페이지를 로딩
|
|
view.loadUrl(url);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onLoadResource(WebView view, String url) {
|
|
// 웹 페이지 리소스들을 로딩하면서 계속해서 호출된다.
|
|
super.onLoadResource(view, url);
|
|
}
|
|
|
|
@Override
|
|
public void onPageFinished(WebView view, String url) {
|
|
// 페이지 로딩시 호출된다.
|
|
//Log.w("RITO", "onPageFinished : " + view.getProgress());
|
|
if(SystemUtil.APP_MODE.equals("active")) { // Browser Mode 인 경우
|
|
if(view.getProgress() == 100) {
|
|
ImageView imageView = (ImageView)findViewById(R.id.imageViewLoading);
|
|
if(imageView.getAlpha() == 1.0) {
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
Thread.sleep(500);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
setWebViewLoadingVisibility(false);
|
|
|
|
}
|
|
}.start();
|
|
//setWebViewLoadingVisibility(false);
|
|
}
|
|
}
|
|
}
|
|
super.onPageFinished(view, url);
|
|
}
|
|
|
|
@Override
|
|
public void onPageStarted(WebView view, String url, Bitmap favicon) {
|
|
// 페이지 요청이 시작될 경우 호출된다.
|
|
super.onPageStarted(view, url, favicon);
|
|
}
|
|
|
|
@Override
|
|
public void onReceivedHttpError(
|
|
WebView view, WebResourceRequest request, WebResourceResponse errorResponse) {
|
|
//Log.w("RITO", "onReceivedHttpError");
|
|
//ImageView imgView = findViewById(R.id.imageViewWait);
|
|
//imgView.setVisibility(View.VISIBLE);
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
Thread.sleep(1000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.reload();
|
|
}
|
|
});
|
|
|
|
}
|
|
}.start();
|
|
//view.reload();
|
|
}
|
|
|
|
@Override
|
|
public void onReceivedError(WebView view, WebResourceRequest request, WebResourceError error) {
|
|
// if(error.getErrorCode() == WebViewClient.ERROR_CONNECT || error.getErrorCode() == WebViewClient.ERROR_TIMEOUT) {
|
|
// setWebViewLoadingVisibility(true);
|
|
// }
|
|
|
|
if(SystemUtil.APP_MODE.equals("active")) { // added by ritoseo for v2.0.9
|
|
setWebViewLoadingVisibility(true);
|
|
|
|
new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
Thread.sleep(1000);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
runOnUiThread(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
view.reload();
|
|
}
|
|
});
|
|
|
|
}
|
|
}.start();
|
|
}
|
|
|
|
|
|
super.onReceivedError(view, request, error);
|
|
}
|
|
|
|
@Override
|
|
public void doUpdateVisitedHistory(WebView view, String url, boolean isReload) {
|
|
// TODO Auto-generated method stub
|
|
super.doUpdateVisitedHistory(view, url, isReload);
|
|
}
|
|
|
|
|
|
@Override
|
|
public void onUnhandledKeyEvent(WebView view, KeyEvent event) {
|
|
|
|
|
|
// TODO Auto-generated method stub
|
|
super.onUnhandledKeyEvent(view, event);
|
|
}
|
|
|
|
@Override
|
|
public boolean shouldOverrideKeyEvent(WebView view, KeyEvent event) {
|
|
if(mWardId != null && mWardId.length() > 0 && mDsrSeq != null && mDsrSeq.length() > 0) {
|
|
if(event.getKeyCode() == KeyEvent.KEYCODE_DPAD_CENTER) { // 지령 확인
|
|
handleDsrConfirm();
|
|
}
|
|
}
|
|
|
|
if(event.getKeyCode() == 183) // RED KEY - SETUP
|
|
return true;
|
|
|
|
if(event.getKeyCode() == KeyEvent.KEYCODE_PROG_YELLOW || event.getKeyCode() == KeyEvent.KEYCODE_PROG_BLUE) { // HDMI - VOLUME KEY
|
|
return true;
|
|
}
|
|
|
|
if(event.getKeyCode() == KeyEvent.KEYCODE_MEDIA_STOP) {
|
|
Log.w(TAG, "[EVENT] 재생 종료 버튼 눌림 - 재생 종료합니다.");
|
|
MainActivity.INSTANCE.mShouldStopPlay = true;
|
|
ritoWebPlayerInterface.quit();
|
|
}
|
|
|
|
if(event.getKeyCode() == 166 && event.getAction() == KeyEvent.ACTION_UP) { // Channel UP
|
|
int chIndex = ritoWebPlayerInterface.getPlayChannelIndex();
|
|
int chCount = ritoWebPlayerInterface.mChannelList.size();
|
|
if(chCount > 0) {
|
|
chIndex++;
|
|
chIndex %= chCount;
|
|
int chno = ritoWebPlayerInterface.mChannelList.get(chIndex).ch_no;
|
|
setChannelOsdVisibility(true, ritoWebPlayerInterface.mChannelList.get(chIndex).title);
|
|
ritoWebPlayerInterface.runChannelList(chno);
|
|
}
|
|
}
|
|
|
|
if(event.getKeyCode() == 167 && event.getAction() == KeyEvent.ACTION_UP) { // Channel Down
|
|
int chIndex = ritoWebPlayerInterface.getPlayChannelIndex();
|
|
int chCount = ritoWebPlayerInterface.mChannelList.size();
|
|
if(chCount > 0) {
|
|
chIndex--;
|
|
if(chIndex < 0) {
|
|
chIndex = chCount - 1;
|
|
}
|
|
int chno = ritoWebPlayerInterface.mChannelList.get(chIndex).ch_no;
|
|
setChannelOsdVisibility(true, ritoWebPlayerInterface.mChannelList.get(chIndex).title);
|
|
ritoWebPlayerInterface.runChannelList(chno);
|
|
}
|
|
}
|
|
|
|
// 키를 오버로딩한것인데 주로 웹페이지를 뒤,앞 등으로 이동하게 한다.
|
|
// 왼쪽키를 누르게 되면 뒤로, 오른쪽 키는 앞으로 가게 한다.
|
|
if(event.getKeyCode() >= 199 && event.getKeyCode() <= 203)
|
|
return true;
|
|
|
|
return super.shouldOverrideKeyEvent(view, event);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private MediaSource buildMediaSource(String assetPath) {
|
|
try {
|
|
// URI 생성
|
|
Uri uri = Uri.parse(assetPath);
|
|
|
|
// AssetDataSource 초기화
|
|
AssetDataSource.Factory assetDataSourceFactory = new DataSource.Factory() {
|
|
@Override
|
|
public DataSource createDataSource() {
|
|
return new AssetDataSource(MainActivity.this);
|
|
}
|
|
};
|
|
|
|
// ProgressiveMediaSource 생성
|
|
return new ProgressiveMediaSource.Factory(assetDataSourceFactory)
|
|
.createMediaSource(MediaItem.fromUri(uri));
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* A native method that is implemented by the 'osic-lib' native library,
|
|
* which is packaged with this application.
|
|
*/
|
|
public native String stringFromJNI();
|
|
public native void nativeInit(String version);
|
|
public native void terminateService();
|
|
public native void doSync();
|
|
public native void setState(String target);
|
|
public native String getIPAddress();
|
|
public native String getNetmask();
|
|
public native String getGateway();
|
|
public native String getServerAddress();
|
|
public native int getServerPort();
|
|
public native String getConfigValue(String target);
|
|
public native String getFileCksum(String target);
|
|
|
|
public native void sendSocketMessage(String target);
|
|
}
|