public class StreamActivity extends AppCompatActivity implements IVLCVout.Callback {
//Lib VLC Defined Variables
public final static String TAG = "LibVLCAndroidSample/VideoActivity";
private SurfaceView mSurface;
private SurfaceHolder holder;
// media player
private LibVLC libvlc;
private MediaPlayer mMediaPlayer = null;
private int mVideoWidth;
private int mVideoHeight;
private final static int VideoSizeChanged = -1;
//Game Controller
private ListView mList;
private ArrayList<String> arrayList;
private MyCustomAdapter mAdapter;
private TCPClient mTcpClient;
public String message = "!CB_DP:0.0";
public String LTmessage = "!LS_LT:0.0";
public String RTmessage = "!RS_RT:0.0";
public String Xmessage = "!LS_LR:0.0";
public String X2message = "!LS_UD:0.0";
public String Ymessage = "!RS_LR:0.0";
public String Y2message = "!RS_UD:0.0";
//public String ConMessage = "!IS_CO:0.0";
/*
public String message = null;
public String LTmessage = null;
public String RTmessage = null;
public String Xmessage = null;
public String X2message = null;
public String Ymessage = null;
public String Y2message = null;
*/
Dpad mDpad = new Dpad();
Handler handler = new Handler();
Handler handler2 = new Handler();
public int delay = 50;
public int delay2 = 20;
/*************
* Activity
*************/
[USER=1021285]@override[/USER]
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
setContentView(R.layout.activity_stream);
//ArrayList LocalIDs = getGameControllerIds();
mSurface = (SurfaceView) findViewById(R.id.surface);
holder = mSurface.getHolder();
setSize(mVideoWidth,mVideoHeight);
//GAME CONTROLLER SECTION:
arrayList = new ArrayList<String>();
mAdapter = new MyCustomAdapter(this, arrayList);
new connectTask().execute("");
handler.postDelayed(new Runnable() {
[USER=1021285]@override[/USER]
public void run() {
mTcpClient.sendMessage(Xmessage);
mTcpClient.sendMessage(Ymessage);
//Toast.makeText(StreamActivity.this, "Yeah Boiiii", Toast.LENGTH_SHORT).show();
handler.postDelayed(this,delay);
}
},delay);
handler2.postDelayed(new Runnable() {
[USER=1021285]@override[/USER]
public void run() {
mTcpClient.sendMessage(X2message);
mTcpClient.sendMessage(Y2message);
//Toast.makeText(StreamActivity.this, "Yeah Boiiii", Toast.LENGTH_SHORT).show();
handler2.postDelayed(this,delay2);
}
},delay);
}
[USER=1021285]@override[/USER]
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
setSize(mVideoWidth, mVideoHeight);
}
[USER=1021285]@override[/USER]
protected void onResume() {
super.onResume();
createPlayer();
//mTcpClient.sendMessage("!IS_CO:YES");
}
[USER=1021285]@override[/USER]
protected void onPause() {
super.onPause();
releasePlayer();
mTcpClient.stopClient();
}
[USER=1021285]@override[/USER]
protected void onDestroy() {
super.onDestroy();
releasePlayer();
mTcpClient.stopClient();
}
/*************
* Surface
*************/
private void setSize(int width, int height) {
mVideoWidth = width;
mVideoHeight = height;
if (mVideoWidth * mVideoHeight <= 1)
return;
if (holder == null || mSurface == null)
return;
// get screen size
int w = getWindow().getDecorView().getWidth();
int h = getWindow().getDecorView().getHeight();
//int w = this.getResources().getDisplayMetrics().widthPixels;
//int h = this.getResources().getDisplayMetrics().heightPixels;
// getWindow().getDecorView() doesn't always take orientation into
// account, we have to correct the values
boolean isPortrait = getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
if (w > h && isPortrait || w < h && !isPortrait) {
int i = w;
w = h;
h = i;
}
float videoAR = (float) mVideoWidth / (float) mVideoHeight;
float screenAR = (float) w / (float) h;
if (screenAR < videoAR)
h = (int) (w / videoAR);
else
w = (int) (h * videoAR);
// force surface buffer size
holder.setFixedSize(mVideoWidth, mVideoHeight);
// set display size
ViewGroup.LayoutParams lp = mSurface.getLayoutParams();
lp.width = w;
lp.height = h;
mSurface.setLayoutParams(lp);
mSurface.invalidate();
}
/*************
* Player
*************/
private void createPlayer() {
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("--file-caching=2000");
//options.add("--subsdec-encoding <encoding>");
//options.add("--aout=false");
//options.add("--avcodec-skiploopfilter");
//options.add("--avcodec-skip-frame=4");
//options.add("--avcodec-skip-idct=4");
//options.add("--network-caching=2");
//options.add("--audio-time-stretch"); // time stretching
options.add("-vvv"); // verbosity
libvlc = new LibVLC(this, options);
holder.setKeepScreenOn(true);
// Create media player
mMediaPlayer = new MediaPlayer(libvlc);
mMediaPlayer.setEventListener(mPlayerListener);
// Set up video output
final IVLCVout vout = mMediaPlayer.getVLCVout();
vout.setVideoView(mSurface);
vout.addCallback(this);
vout.attachViews();
Media m = new Media(libvlc, Uri.parse("rtsp://root:4977@192.168.127.9:554/axis-media/media.amp"));
m.setHWDecoderEnabled(true,false);
m.addOption(":network-caching=150");
m.addOption(":clock-jitter=0");
m.addOption(":clock-synchro=0");
mMediaPlayer.setMedia(m);
mMediaPlayer.setAspectRatio("16:9");
mMediaPlayer.setScale(1.0f);
mMediaPlayer.play();
} catch (Exception e) {
Toast.makeText(this, "Error creating player!", Toast.LENGTH_LONG).show();
}
}
// TODO: handle this cleaner
private void releasePlayer() {
if (libvlc == null)
return;
mMediaPlayer.stop();
final IVLCVout vout = mMediaPlayer.getVLCVout();
vout.removeCallback(this);
vout.detachViews();
holder = null;
libvlc.release();
libvlc = null;
mVideoWidth = 0;
mVideoHeight = 0;
}
/*************
* Events
*************/
private MediaPlayer.EventListener mPlayerListener = new MyPlayerListener(this);
public void onNewLayout(IVLCVout vout, int width, int height, int visibleWidth, int visibleHeight, int sarNum, int sarDen) {
if (width * height == 0)
return;
// store video size
mVideoWidth = width;
mVideoHeight = height;
setSize(mVideoWidth, mVideoHeight);
}
[USER=1021285]@override[/USER]
public void onSurfacesCreated(IVLCVout vout) {
setSize(mVideoWidth,mVideoHeight);
}
[USER=1021285]@override[/USER]
public void onSurfacesDestroyed(IVLCVout vout) {
}
private static class MyPlayerListener implements MediaPlayer.EventListener {
private WeakReference<StreamActivity> mOwner;
public MyPlayerListener(StreamActivity owner) {
mOwner = new WeakReference<StreamActivity>(owner);
}
[USER=1021285]@override[/USER]
public void onEvent(MediaPlayer.Event event) {
StreamActivity player = mOwner.get();
switch (event.type) {
case MediaPlayer.Event.EndReached:
player.releasePlayer();
break;
case MediaPlayer.Event.Playing:
case MediaPlayer.Event.Paused:
case MediaPlayer.Event.Stopped:
default:
break;
}
}
}
public class connectTask extends AsyncTask<String, String, TCPClient> {
[USER=1021285]@override[/USER]
protected TCPClient doInBackground(String... message) {
//we create a TCPClient object and
mTcpClient = new TCPClient(new TCPClient.OnMessageReceived() {
[USER=1021285]@override[/USER]
//here the messageReceived method is implemented
public void messageReceived(String message) {
//this method calls the onProgressUpdate
publishProgress(message);
}
});
mTcpClient.run();
return null;
}
[USER=1021285]@override[/USER]
protected void onProgressUpdate(String... values) {
super.onProgressUpdate(values);
//in the arrayList we add the messaged received from server
arrayList.add(values[0]);
// notify the adapter that the data set has changed. This means that new message received
// from server was added to the list
mAdapter.notifyDataSetChanged();
}
}
/*
public ArrayList getGameControllerIds() {
ArrayList gameControllerDeviceIds = new ArrayList();
int[] deviceIds = InputDevice.getDeviceIds();
for (int deviceId : deviceIds) {
InputDevice dev = InputDevice.getDevice(deviceId);
int sources = dev.getSources();
// Verify that the device has gamepad buttons, control sticks, or both.
if (((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)
|| ((sources & InputDevice.SOURCE_JOYSTICK)
== InputDevice.SOURCE_JOYSTICK)) {
// This device is a game controller. Store its device ID.
ConMessage = "!IS_CO:YES";
mTcpClient.sendMessage(ConMessage);
if (!gameControllerDeviceIds.contains(deviceId)) {
gameControllerDeviceIds.add(deviceId);
}
}
}
return gameControllerDeviceIds;
}*/
[USER=1021285]@override[/USER]
public boolean onGenericMotionEvent(MotionEvent event){
boolean handled_motion = false;
if(Dpad.isDpadDevice(event)){
int press = mDpad.getDirectionPressed(event);
switch(press){
case Dpad.LEFT:
message = "!CB_DP:LEFT";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
//DirectionPressedView.setText("Left");
handled_motion = true;
break;
case Dpad.RIGHT:
message = "!CB_DP:RIGHT";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
//DirectionPressedView.setText("Right");
handled_motion = true;
break;
case Dpad.DOWN:
message = "!CB_DP:DOWN";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
//DirectionPressedView.setText("Down");
handled_motion = true;
break;
case Dpad.UP:
message = "!CB_DP:UP";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
//DirectionPressedView.setText("Up");
handled_motion = true;
break;
}
}
//Handle Joystick Movements
if ((event.getSource() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK && event.getAction() == MotionEvent.ACTION_MOVE){
final int historySize = event.getHistorySize();
// Process the movements starting from the
// earliest historical position in the batch
for (int i = 0; i < historySize; i++) {
// Process the event at historical position i
processJoystickInput(event, i);
}
processJoystickInput(event, -1);
handled_motion = true;
}
if(handled_motion){
return true;
}
return super.onGenericMotionEvent(event);
}
public boolean onKeyDown(int keyCode, KeyEvent event){
boolean handled = false;
// Handle Button Presses
if((event.getSource() & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD){
if(event.getRepeatCount() == 0){
// STEELSERIES CONTROLLER:
if(keyCode == KeyEvent.KEYCODE_BUTTON_A){
message = "!CB_SB:A";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_B){
message = "!CB_SB:B";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_X){
message = "!CB_SB:X";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_Y){
message = "!CB_SB:Y";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_THUMBL){
message = "!CB_SB:L3";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_THUMBR){
message = "!CB_SB:R3";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_L1){
message = "!CB_SB:L1";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_R1){
message = "!CB_SB:R1";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BUTTON_START){
message = "!CB_SB:START";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else if(keyCode == KeyEvent.KEYCODE_BACK){
message = "!CB_SB:BACK";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
else{
message = "!CB_SB:SELECT";
if (mTcpClient != null) {
mTcpClient.sendMessage(message);
}
handled = true;
}
}
}
if(handled){
return true;
}
return super.onKeyDown(keyCode, event);
}
private void processJoystickInput(MotionEvent event, int historyPos){
InputDevice mInputDevice = event.getDevice();
/*
if (x == 0){
x = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_HAT_X, historyPos);
}*/
/*
if (y == 0) {
y = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_HAT_Y, historyPos);
}*/
float LeftT = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_BRAKE,historyPos);
float RightT = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_GAS,historyPos);
String messageLT = String.valueOf(LeftT);
LTmessage = "!LS_LT:" + messageLT;
if (mTcpClient != null) {
mTcpClient.sendMessage(LTmessage);
}
String messageRT = String.valueOf(RightT);
RTmessage = "!RS_RT:" + messageRT;
if (mTcpClient != null) {
mTcpClient.sendMessage(RTmessage);
}
float x = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_X, historyPos);
float y = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_Y, historyPos);
String messagex = String.valueOf(x);
Xmessage = "!LS_LR:" + messagex;
if (mTcpClient != null) {
mTcpClient.sendMessage(Xmessage);
}
String messagey = String.valueOf(y);
Ymessage = "!LS_UD:" + messagey;
if (mTcpClient != null) {
mTcpClient.sendMessage(Ymessage);
}
float x2 = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_Z, historyPos);
float y2 = getCenteredAxis(event, mInputDevice, MotionEvent.AXIS_RZ, historyPos);
String messagex2 = String.valueOf(x2);
X2message = "!RS_LR:" + messagex2;
if (mTcpClient != null) {
mTcpClient.sendMessage(X2message);
}
String messagey2 = String.valueOf(y2);
Y2message = "!RS_UD:" + messagey2;
if (mTcpClient != null) {
mTcpClient.sendMessage(Y2message);
}
}
private static float getCenteredAxis(MotionEvent event, InputDevice device, int axis, int historyPos){
final InputDevice.MotionRange range = device.getMotionRange(axis, event.getSource());
if (range != null){
final float flat = range.getFlat();
final float value = historyPos < 0 ? event.getAxisValue(axis): event.getHistoricalAxisValue(axis,historyPos);
if (Math.abs(value) > flat){
return value;
}
}
return 0;
}
}
