咸鱼

val intent = Intent(this, VideoPlaybackListPPCSActivity::class.java).apply {
    this.putExtra("data",111)
}

// 此方法已过期
// Deprecated
// use registerForActivityResult(ActivityResultContract, ActivityResultCallback) passing in a androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult object for the ActivityResultContract.
startActivityForResult(intent,10090)

//初始化不能在按键事件等地方执行，建议在onCreate执行
val launcher = registerForActivityResult(object: ActivityResultContract<String,String>(){
    override fun createIntent(context: Context, input: String?): Intent {

        return Intent(this@VideoPlayerPPCSActivity, VideoPlaybackListPPCSActivity::class.java).apply{
            intent.extras?.let { ext ->
                ext.putInt("session",remoteCamera.getSession())
                this.putExtras(ext)
            }
        }
    }
    override fun parseResult(resultCode: Int, intent: Intent?): String {
        
        //解析Intent中的数据，返回给onActivityResult
        //这里不需要数据
        return "ok"
    }
},object: ActivityResultCallback<String>{
    override fun onActivityResult(result: String?) {
        
        //拿到数据
    }
})


// 需要跳转时，这样执行 
val intent = Intent(this, VideoPlaybackListPPCSActivity::class.java).apply {
    this.putExtra("data",111)
}
launcher.launch(intent)

String channelId = "news";
   NotificationCompat.Builder builder = new NotificationCompat.Builder(getApplicationContext(),
           channelId)
           .setSmallIcon(R.mipmap.ic_launcher)
           .setContentTitle("测试Title")
           .setContentText("一些简单的内容！！！");

   NotificationManagerCompat notificationManager = NotificationManagerCompat.from(getApplicationContext());

   int notifyId = 123;
   notificationManager.notify(notifyId, builder.build());

import android.util.Log;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.concurrent.TimeUnit;

public class UDPSearch{

    private final String TAG = this.getClass().getSimpleName();
    private final Object mLock;
    private DatagramSocket socket = null;
    private UDPCallback callback;
    private Thread threadReceive,threadSend;

    public UDPSearch(UDPCallback callback) {
        this.callback = callback;
        this.mLock = new Object();
    }


    public void start(){

        threadReceive = new Thread(new UDPReceive());
        threadSend = new Thread(new UDPSend());

        threadReceive.start();
        threadSend.start();
    }
    public void stop(){

        if(threadSend != null){
            threadSend.interrupt();
            threadSend = null;
        }
        if(threadReceive != null){
            threadReceive.interrupt();
            threadReceive = null;
        }
    }


    class UDPSend implements Runnable{

        private final String TAG = this.getClass().getSimpleName();
        private final int BROADCAST_PORT = 6666;
        private final String BROADCAST_HOST = "255.255.255.255";
        private final byte[] broadcastData = new byte[]{ 0x01 ,0x02, 0x03 ,0x04 };

        @Override
        public void run() {

            Log.i(TAG,"run start");

            try {

                TimeUnit.SECONDS.sleep(2);
                InetAddress inetAddress = InetAddress.getByName(BROADCAST_HOST);
                socket = new DatagramSocket();
                socket.setBroadcast(true);

                Log.d(TAG, "create udp socket target port:" + socket.getPort() + " and local port : " + socket.getLocalPort());
                //socket已创建，通知线程接收数据
                synchronized (mLock){
                    mLock.notify();
                    Log.i(TAG, "notify create socket ok");
                }
                while (!Thread.currentThread().isInterrupted()) {
                    Log.d(TAG,"send udp broadcast target port: " + BROADCAST_PORT);
                    try{
                        socket.send(new DatagramPacket(broadcastData, broadcastData.length,
                                inetAddress, BROADCAST_PORT));
                    }catch (IOException io){
                        // 这种错误不应该结束发送广播，系统网络关闭可以复现。
                        // java.io.IOException: sendto failed: ENETUNREACH (Network is unreachable)
                        // Caused by: android.system.ErrnoException: sendto failed: ENETUNREACH (Network is unreachable)
                        io.printStackTrace();
                    }
                    TimeUnit.SECONDS.sleep(2);
                }
            } catch (InterruptedException | UnknownHostException | SocketException e) {
                e.printStackTrace();
            }finally {
                Log.i(TAG,"socket close");
                if(socket != null){
                    socket.close();
                    socket = null;
                }
            }
            Log.i(TAG,"stop");
        }
    }


    class UDPReceive implements Runnable{

        private final String TAG = this.getClass().getSimpleName();

        @Override
        public void run() {

            Log.i(TAG,"run start");
            if(socket == null){
                try {
                    Log.w(TAG,"socket not init, wait mLock.");
                    synchronized (mLock){
                        mLock.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Log.i(TAG, "stop wait mLock");
            while (socket != null && !Thread.currentThread().isInterrupted()) {
                try {
                    final int len = 256;
                    DatagramPacket datagramPacket = new DatagramPacket(new byte[len], len);
                    Log.i(TAG, "receive data block");
                    socket.receive(datagramPacket);
                    Log.i(TAG, "receive data size = " + datagramPacket.getLength());
                    callback.onReceivePacket(datagramPacket.getData(), datagramPacket.getLength());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            Log.i(TAG,"stop");
        }
    }


}

public interface UDPCallback {
    void onReceivePacket(byte[] data, int len);
}

@Data
public class User {

    @NotBlank(message = "name不能为空")
    private String name;
}

import org.springframework.validation.annotation.Validated;

@PostMapping("/register")
   public ResponseEntity<Void> register(@Validated User user) {

       return ResponseEntity.noContent().build();
   }