用uniapp 及socket.io做一个简单聊天 升级 9

news2024/11/14 20:18:06
比这之前优化了以下功能
上线通知
群聊里适时显示在线人数
约请好友 通过好友通过socket 相应端自动变化
PC端可以拉取摄象头拍照
PC端可以录音发送
拉起摄象头发送录象

在这里插入图片描述

<template>
	<view class="">
		<scroll-view scroll-y="true" class="scroll-box"
			:style="{ height: `${windowObj.windowHeight - windowObj.statusBarHeight - 94}px` }"
			:scroll-top="scrollHeight" @scrolltoupper="loadMores">
			<view class="group-box">
				在线{{userList.length}}人：
				<text class="group-member" v-for="(item, index) in userList" :key="index">
					{{item}} 
				</text>

			</view>
			<view class="scroll-view">
				<view class="news-box" v-for="(item, index) in list" :key="index">
					<view class="message-type" v-if="['left', 'join', 'kick'].includes(item.type)">
						{{ item.content }} {{(formatDate(Date()))}}
					</view>
					<image class="avatar" :class="[item.isMe ? 'is-me' : 'avatar-right']" :src="item.avatar"
						mode="aspectFill" v-if="!['kick', 'join', 'left'].includes(item.type)" @tap="kickopen(item)">
					</image>
					<view class="message-box" :class="{ 'is-me': item.isMe }"
						v-if="!['kick', 'join', 'left'].includes(item.type)">
						<text class="message" v-if="item.type === 'text'">
							<image src="../../static/withdraw.png"
								style="width: 40rpx; height: 40rpx;position:relative;right:16rpx;bottom:1rpx;"
								mode="aspectFill" v-if="item.isMe && canwithdraw(item) && item.withdraw === 0"
								@tap="withdraw(item)"></image>
							<text :selectable="true" @tap="copyBtnClick(item.content)" > {{formatMessage(item.content || '')}}</text>
							
						</text>
						<text class="message_img" v-if="['image', 'video', 'audio'].includes(item.type)">
							<template v-if="item.type === 'image'">
								<image class="message-image" :src="item.content" mode="aspectFill"
									@click="previewImage(item.content)" />
							</template>
							<template v-if="item.type === 'video'">
								<video v-if="item.content" :src="item.content" controls></video>
							</template>
							<template v-if="item.type === 'audio'">
								<audio v-if="item.content" :src="item.content" controls ></audio>
							</template>
							<image src="../../static/withdraw.png" style="width: 50rpx; height: 50rpx" mode="aspectFill"
								v-if="item.isMe && canwithdraw(item) && item.withdraw === 0" @click="withdraw(item)">
							</image>
						</text>
					</view>
				</view>
			</view>
		</scroll-view>
		<view class="base-btn" :class="{ 'base-btn-popup-open': isPopupOpen || isPopupAudioOpen }">
			<view class="base-con unify-flex">
				<view @tap="more">
					<image src="../../static/chat/more.png" style="width: 50rpx; height: 50rpx"></image>
				</view>
				<input class="input-text" type="text" :value="inputValue" placeholder="说些什么吧" @input="getInput"
					@confirm="tapTo(2)" />
				<view @click="tapTo(2)">
					<image src="../../static/chat/chat.png" style="width: 50rpx; height: 50rpx"></image>
				</view>
			</view>
		</view>
		<uni-popup ref="popup" type="bottom" :style="{ height: '200rpx' }" @change="onPopupChange">
			<view class="popup-content"
				:style="{ width: '100%', backgroundColor: '#fff', height: '200rpx', overflowY: 'scroll' }">
				<view class="popup-items">
					<view class="popup-item" v-if="type === 'group'" @tap="adduserTogroup">
						<image src="../../static/chat/add.png" style="width: 50rpx; height: 50rpx"></image>
						<text>添加</text>
					</view>
					<view class="popup-item" @click="chooseFile">
						<image src="../../static/chat/pic.png" style="width: 50rpx; height: 50rpx"></image>
						<text>图片</text>
					</view>
					<view class="popup-item" @tap="audio">
						<image src="../../static/chat/audio.png" style="width: 50rpx; height: 50rpx"></image>
						<text>音频</text>
					</view>
					<view class="popup-item" @tap="openCamera">
						<image src="../../static/chat/video.png" style="width: 50rpx; height: 50rpx"></image>
						<text>视频</text>
					</view>
					<view class="popup-item" @tap="groupdetail">
						<image src="../../static/chat/detail.png" style="width: 50rpx; height: 50rpx"></image>
						<text>详情</text>
					</view>
					<view class="popup-item" v-if="type === 'group'" @tap="quitgroup">
						<image src="../../static/chat/exit-group.png" style="width: 50rpx; height: 50rpx"></image>
						<text>退群</text>
					</view>
				</view>
			</view>
		</uni-popup>
		<uni-popup ref="popupAudio" type="bottom" :style="{ height: '200rpx' }" @change="onPopupAudioChange">
			<view class="popup-content"
				:style="{ width: '100%', backgroundColor: '#fff', height: '200rpx', overflowY: 'scroll' }">
				<view class="popup-item" @click="startRecording">
					<image src="../../static/chat/beginaudio.png" style="width: 50rpx; height: 50rpx"></image>
					<text>录音</text>
				</view>
				<view class="popup-item" @click="stopRecording">
					<image src="../../static/chat/send.png" style="width: 50rpx; height: 50rpx"></image>
					<text>发送录音</text>
				</view>
		<!-- 		<view class="popup-item" @tap="playRecording">
					<image src="../../static/chat/play.png" style="width: 50rpx; height: 50rpx"></image>
					<text>播放</text>
				</view> -->
			<!-- 	<view class="popup-item" @tap="upsong">
					<image src="../../static/chat/send.png" style="width: 50rpx; height: 50rpx"></image>
					<text>发送</text>
				</view> -->
				<view class="popup-item" @tap="exitchat">
					<image src="../../static/chat/exit.png" style="width: 50rpx; height: 50rpx"></image>
					<text>退出</text>
				</view>
			</view>
		</uni-popup>
		<uni-popup ref="popupkick" type="bottom" :style="{ height: '200rpx' }" @change="onPopupAudioChange">
			<view class="popup-content"
				:style="{ width: '100%', backgroundColor: '#fff', height: '200rpx', overflowY: 'scroll' }">
				<view class="popup-item" @click="kick('kick')">
					<image src="../../static/chat/kickp.png" style="width: 50rpx; height: 50rpx"></image>
					<text>踢人</text>
				</view>
				<view class="popup-item" @click="kick('black')">
					<image src="../../static/chat/black.png" style="width: 50rpx; height: 50rpx"></image>
					<text>拉黑</text>
				</view>
				<view class="popup-item" @tap="detail">
					<image src="../../static/chat/detail.png" style="width: 50rpx; height: 50rpx"></image>
					<text>详情</text>
				</view>

			</view>
		</uni-popup>
	</view>
</template>
<script>
	import io from 'socket.io-client';
	import config from '@/config/config.js';
	import {
		mapState,
		mapActions
	} from 'vuex';
	import {
		v4 as uuidv4
	} from 'uuid';
	import {
		getCurrentDateTime
	} from '@/common/dateFormatter.js'
	import { handleClipboard } from '@/common/clipboardone.js';


	export default {
		data() {
			return {
				name: '',
				inputValue: '',
				list: [],
				image: '',
				scrollHeight: 0,
				userList: '',
				type: '',
				socket: null,
				messages: [],
				groupName: '',
				tid: '',
				toid: 0,
				receiver_type: '',
				isPopupOpen: false,
				isPopupAudioOpen: false,
				selectedFilePath: '',
				group_owner_id: 0, //群主id
				fid: '',
				to_id: 0,
				recordingPath: '', // 用于存储录音文件的路径
		    	  isRecording: false,
			      mediaRecorder: null,
			      audioChunks: []
			};
		},
		computed: {
			...mapState(['user']),
			windowObj() {
				let obj;
				uni.getSystemInfo({
					success: (res) => {
						obj = res;
					}
				});
				return obj;
			}
		},
		watch: {
			isPopupOpen(newValue) {
				if (!newValue) {
					this.$refs.popup.close();
				}
			},

			isPopupAudioOpen(newValue) {
				if (!newValue) {
					this.$refs.popupAudio.close();
				}
			}
		},
		async onLoad(q) {
	
			let _ = this;
			try {
				if (q && q.id != undefined) {
					this.groupName = q.id;
					this.tid = q.tid;
					this.to_id = q.to_id
					this.receiver_type = q.type;
					this.type = this.receiver_type
					uni.setNavigationBarTitle({
						title: q.type == 'group' ? '[群聊] '+q.to_name: '[私聊] '+q.to_name
					});

					if (q.type == 'group') {
						//将q.id的前面g_去掉
						let newid = q.id.replace('g_', '')
						//获到了当前群的群主id
						let re = await _.getGroupOwner(newid)
						this.group_owner_id = re.data.data.owner_id
					}
					let re = await _.checkFriend(q.id);
					if (re == true) {
						_.joinGroup(this.groupName);
					} else {
						uni.navigateTo({
							url: '/pages/index/friends'
						});
					}
				} else {
					uni.navigateTo({
						url: '/pages/index/friends'
					});
				}
			} catch (e) {
				uni.navigateTo({
					url: '/pages/index/friends'
				});
			}

		},
		onUnload() {
			this.socket.close();
		},

		onShow() {
			this.fetchUser();
		},

		mounted() {

			this.initChatLog();
			this.socket = io(config.apiBaseUrl);
			this.socket.on('connect', () => {
				console.log('Socket connected:', this.socket.id);
			});
			this.socket.on('disconnect', () => {
				console.log('Socket disconnected');
			});

			let heartbeatInterval;
			let reconnectAttempts = 0;
			const maxReconnectAttempts = 10;

			const startHeartbeat = () => {
				heartbeatInterval = setInterval(() => {
					if (this.socket.connected) {
						this.socket.emit('heartbeat');
						console.log('heartbeat')
					} else {
						reconnectSocket();
					}
				}, 120000); // 1分钟
			};

			const reconnectSocket = () => {
				if (reconnectAttempts < maxReconnectAttempts) {
					this.socket.connect();
					reconnectAttempts++;
				} else {
					clearInterval(heartbeatInterval);
					uni.showModal({
						title: '连接失败',
						content: '无法连接到服务器，是否手动重新连接？',
						confirmText: '重新连接',
						cancelText: '取消',
						success: (res) => {
							if (res.confirm) {
								reconnectAttempts = 0;
								this.socket.connect();
								startHeartbeat();
							}
						}
					});
				}
			};

			startHeartbeat();

			this.socket.on('reconnect', () => {
				console.log('Socket重新连接成功');
				reconnectAttempts = 0;
			});





			
			this.socket.on('message', (msg) => {

				if (msg.type == 'broadcast') {
					return;
				}
				if (msg.type == 'widthdraw') {

					//查出 msg.sn 将此记录信息改为撤回
					//console.log(msg);
					this.list.forEach((item, index) => {
						if (item.sn == msg.content) {
							this.list[index].content = '[消息已撤回]';
							this.list[index].type = 'text';
							this.list[index].withdraw = 1;
							this.widthdrawRow(item.sn)
						}
					});
					return;
				}
				let msgs = {
					sn: msg.sn,
					name: msg.user_name,
					avatar: msg.avatar,
					isMe: msg.fid == this.user.id ? true : false,
					content: msg.content,
					type: msg.type,
					sn: msg.sn,
					createat: Math.floor(Date.now() / 1000),
					time: Date.now(),
					withdraw: 0,
					toid: msg.fid
				};

				this.list.push(msgs);
				this.setScrollTop();
			});

			// 监听 'userList' 事件
			this.socket.on('userList', (users) => {
				this.userList = users; // 更新 userList 变量
				console.log('- 当前群用户 -')
				console.log(this.userList)

			});

		},
		methods: {
			...mapActions(['fetchUser', 'logout', 'fetchGroups']),
			formatDate() {
				return getCurrentDateTime();
			},
			kickopen(item) {
				this.name = item.name
				this.toid = item.toid
				if (!item.isMe) {
					this.$refs.popupkick.open()
				}
			},
			getGroupOwner(id) {
				//接口 group 提交id 获取到群的信息
				const token = uni.getStorageSync('token');
				return new Promise((resolve, reject) => {
					uni.request({
						url: `${config.apiBaseUrl}/group`,
						method: 'GET',
						header: {
							Authorization: `Bearer ${token}`
						},
						data: {
							id: id
						},
						success: (res) => {
							resolve(res)

						},
						fail: (err) => {
							reject(err)
						}
					});
				})
			},

			async widthdrawRow(sn) {
				const token = uni.getStorageSync('token');
				if (!token) return;
				try {
					const [error, response] = await uni.request({
						url: `${config.apiBaseUrl}/withdraw`,
						method: 'GET',
						header: {
							Authorization: `Bearer ${token}`
						},
						data: {
							sn: sn
						}
					});
					if (error) {
						throw new Error(`Request failed with error: ${error}`);
					}
					if (response.data.code === 0) {
						return true;
					} else {
						return false;
					}
				} catch (error) {
					return false;
				}

			},
			adduserTogroup() {
				this.isPopupOpen=false
				uni.navigateTo({
					url: '/pages/index/addfriend?groupId=' + this.tid
				});
			},

			kick(type) {
				//将用户踢出去

				if (this.group_owner_id != this.fid) {
					//这样才能踢	
					if (type == 'kick') {
						this.kickUser(this.name)
					} else {
						//拉黑
						this.kickUser(this.name, 'black')
						//再拉黑
					}
				} else {
					uni.showToast({
						title: '不能对自己操作'
					})
				}
			},

			detail() {
				uni.navigateTo({
					url: '/pages/index/about?id=' + this.to_id
				});
			},
			groupdetail() {

				let groupid = this.groupName.replace('g_', '')
				if (this.type == 'group') {
					uni.navigateTo({
						url: '/pages/index/groupdetail?id=' + groupid
					});
				} else {

					uni.navigateTo({
						url: '/pages/index/about?id=' + this.to_id
					});

				}


			},
			async quitgroup() {
				console.log(this.group_owner_id)
				console.log(this.user.id)
				if (this.group_owner_id == this.user.id) {
					//主人不能退群
					uni.showToast({
						title: '主人不能退群'
					})
					return
				}

				let groupid = this.groupName.replace('g_', '')

				//调用接口退出 接口名为leavgroup 	
				const token = uni.getStorageSync('token');
				if (!token) return;

				try {
					const [error, response] = await uni.request({
						url: `${config.apiBaseUrl}/leavgroup`,
						method: 'GET',
						header: {
							Authorization: `Bearer ${token}`
						},
						data: {
							groupid
						}
					});
					if (error) {
						throw new Error(`Request failed with error: ${error}`);
					}
					console.log(response)
					if (response.data.code === 0) {
						uni.navigateTo({
							url: '/pages/index/friends'
						})
						return true;

					} else {
						return false;
					}
				} catch (error) {
					return false;
				}
			},
			onPopupChange() {
				if (this.isPopupOpen == true) {
					this.isPopupOpen = false;
				}
			},
			playVoice(url) {
			// 创建音频对象
						const audio = new Audio(url);
						// 播放音频
						audio.play().then(() => {
							console.log('音频开始播放');
						}).catch((error) => {
							console.error('音频播放失败:', error);
						});

						// 监听音频播放结束事件
						audio.onended = () => {
							console.log('音频播放结束');
						};
			},
			onPopupAudioChange() {
				if (this.isPopupOpen == true) {
					this.isPopupOpen = false;
				}
				this.recordingPath = '';
			},
			audio() {
				this.$refs.popup.close();
				this.$refs.popupAudio.open();
				this.isPopupOpen = true;
			},
			exitchat() {
				this.$refs.popupAudio.close();
			},
		async 	startRecording() {
			
				    try {


						if(this.isRecording){
							uni.showToast({
								title: '正在录音中',
								icon: 'none',
								duration: 2000
							});
							return;
						}

						
				        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
				        this.mediaRecorder = new MediaRecorder(stream);
						
						//console.log(this.mediaRecorder);
				        this.mediaRecorder.ondataavailable = (event) => {
				          this.audioChunks.push(event.data);
				        };
				        this.mediaRecorder.onstop  = async () => {


							const audioBlob = new Blob(this.audioChunks, { type: 'audio/wav' });
								const url = URL.createObjectURL(audioBlob);
								this.selectedFilePath = url;
				          // 创建一个提示框
				          const confirmResult = await new Promise((resolve) => {
				            uni.showModal({
				              title: '录音完成',
				              content: '是否上传录音？',
				              confirmText: '上传',
				              cancelText: '取消',
				              success: (res) => {
							
							
								resolve(true);
				              }
				            });
				          });

				          // 如果用户选择取消，则不继续处理
				          if (!confirmResult) {
				            this.audioChunks = [];
				            this.isRecording = false;
				            return;
				          }else{
							this.uploadAvatar('audio');
							
						  }
						  this.isPopupOpen=false;
				   
						  this.isRecording=false;

				          // 清理本地声音
				          stream.getTracks().forEach(track => track.stop());
				          URL.revokeObjectURL(url);


				        };
				        this.mediaRecorder.start();
				        this.isRecording = true;
				
						
				      } catch (error) {
				        console.error('获取麦克风权限失败：', error);
				      }
		
			},
		     async stopRecording() {

				//console.log('停止录音')


				 if (this.mediaRecorder) {
				        this.mediaRecorder.stop();
				        this.isRecording = false;
						this.popupAudio=false;
						
				 }else{
					uni.showToast({
						title: '没有录音',
						icon: 'none'
					});
				 }
			     
				  
			},


			
			
			 uploadAudio(audioBlob) {
				 
				 
			      const formData = new FormData();
			      formData.append('audio', audioBlob, 'recorded_audio.wav');
			      console.log(URL.createObjectURL(audioBlob))
				  const token = uni.getStorageSync('token');
			      uni.uploadFile({
			      	url: `${config.apiBaseUrl}/upload`,
			        filePath: URL.createObjectURL(audioBlob),
			        name: 'avatar',
					header: {
						Authorization: `Bearer ${token}`
					},
			       // formData: formData,
			        success: (uploadFileRes) => {
					 const response = JSON.parse(uploadFileRes.data);
					 if (response.code == 0) {
					 	const avatarUrl = response.data;
					 	this.sendMessage(avatarUrl, 'audio');
					 }
					 
					 
			        },
			        fail: (err) => {
			          //console.error('上传失败：', err);
					  console.error('Failed to upload avatar:', error);
					  uni.showToast({
					  	title: '上传失败',
					  	icon: 'none'
					  });
			        }
			      });
			    },
			
			
			playRecording() {
				if (this.recordingPath) {
					const innerAudioContext = uni.createInnerAudioContext();
					innerAudioContext.src = this.recordingPath;

					innerAudioContext.onPlay(() => {
						console.log('开始播放录音');
					});

					innerAudioContext.onError((res) => {
						console.error('播放录音失败:', res);
					});

					innerAudioContext.play();
				} else {
					uni.showToast({
						title: '没有可播放的录音',
						icon: 'none'
					});
				}
			},
			upsong() {
	
				const token = uni.getStorageSync('token');
				uni.uploadFile({
					url: `${config.apiBaseUrl}/upload`,
					filePath: this.selectedFilePath,
					name: 'avatar',
					header: {
						Authorization: `Bearer ${token}`
					},
					success: async (uploadFileRes) => {
						const response = JSON.parse(uploadFileRes.data);
						if (response.code == 0) {
							const avatarUrl = response.data;
							this.sendMessage(avatarUrl, type);
						}
					},
					fail: (error) => {
						console.error('Failed to upload avatar:', error);
						uni.showToast({
							title: '上传失败',
							icon: 'none'
						});
					}
				});  
				  
				  
			},

			more() {
				this.$refs.popup.open();
				this.isPopupOpen = true;
			},

			openCamera() {

				if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
					navigator.mediaDevices.getUserMedia({ video: true, audio: true })
						.then((stream) => {
							// 创建视频元素
							const video = document.createElement('video');
							video.srcObject = stream;
							video.autoplay = true;
							
							// 创建容器
							const container = document.createElement('div');
							container.style.position = 'fixed';
							container.style.top = '0';
							container.style.left = '0';
							container.style.width = '100%';
							container.style.height = '100%';
							container.style.backgroundColor = 'rgba(0,0,0,0.8)';
							container.style.zIndex = '9999';
							
							container.appendChild(video);
							document.body.appendChild(container);
							
							// 创建录制器
							const mediaRecorder = new MediaRecorder(stream);
							let chunks = [];
							
							mediaRecorder.ondataavailable = (e) => {
								chunks.push(e.data);
							};
							
							mediaRecorder.onstop = () => {
								const blob = new Blob(chunks, { type: 'video/webm' });
								chunks = [];
								const videoUrl = URL.createObjectURL(blob);
								this.selectedFilePath = videoUrl;
								this.uploadAvatar('video');
							};
							
							// 开始录制
							mediaRecorder.start();
							
							// 添加上传按钮
							const uploadButton = document.createElement('button');
							uploadButton.textContent = '停止录制并上传';
							uploadButton.style.position = 'absolute';
							uploadButton.style.bottom = '10px';
							uploadButton.style.left = '50%';
							uploadButton.style.transform = 'translateX(-50%)';
							uploadButton.onclick = () => {
								mediaRecorder.stop();
								stream.getTracks().forEach(track => track.stop());
								document.body.removeChild(container);
							};
							
							container.appendChild(uploadButton);
						})
						.catch((error) => {
							console.error('无法访问摄像头:', error);
							uni.showToast({
								title: '无法访问摄像头',
								icon: 'none'
							});
						});
				} else {
					uni.showToast({
						title: '您的设备不支持摄像头',
						icon: 'none'
					});
				}
				// if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
				// 			navigator.mediaDevices.getUserMedia({ video: true })
				// 				.then((stream) => {
				// 					// 创建一个 video 元素来显示摄像头画面
				// 					const video = document.createElement('video');
				// 					video.srcObject = stream;
				// 					video.autoplay = true;
									
				// 					// 创建一个容器来放置 video 元素
				// 					const container = document.createElement('div');
				// 					container.style.position = 'fixed';
				// 					container.style.top = '0';
				// 					container.style.left = '0';
				// 					container.style.width = '100%';
				// 					container.style.height = '100%';
				// 					container.style.backgroundColor = 'rgba(0,0,0,0.8)';
				// 					container.style.zIndex = '9999';
									
				// 					container.appendChild(video);
				// 					document.body.appendChild(container);
									
				// 					// 创建一个 canvas 元素用于捕获视频帧
				// 					const canvas = document.createElement('canvas');
									
				// 					// 添加一个按钮来关闭摄像头并上传图片
				// 					const closeButton = document.createElement('button');
				// 					closeButton.textContent = '拍照并上传';
				// 					closeButton.style.position = 'absolute';
				// 					closeButton.style.bottom = '10px';
				// 					closeButton.style.left = '50%';
				// 					closeButton.style.transform = 'translateX(-50%)';
				// 					closeButton.onclick = () => {
				// 						// 捕获当前视频帧
				// 						canvas.width = video.videoWidth;
				// 						canvas.height = video.videoHeight;
				// 						canvas.getContext('2d').drawImage(video, 0, 0, canvas.width, canvas.height);
										
				// 						// 将 canvas 转换为 Blob
				// 						canvas.toBlob((blob) => {
				// 							// 停止所有视频轨道
				// 							stream.getTracks().forEach(track => track.stop());
											
				// 							// 移除容器
				// 							document.body.removeChild(container);
											
				// 							// 创建一个临时的 URL
				// 							const imageUrl = URL.createObjectURL(blob);
				// 							// 将Blob转换为File对象，并设置.mp4后缀
				// 							//const file = new File([blob], 'captured_video.mp4', { type: 'video/mp4' });
				// 							// 创建新的临时URL
										
											
											
				// 							// 设置 selectedFilePath 并调用 uploadAvatar
				// 							this.selectedFilePath = imageUrl;
				// 							this.uploadAvatar('video');
											
				// 							// 清理临时 URL
				// 							URL.revokeObjectURL(imageUrl);
				// 						}, 'image/jpeg');
				// 					};
				// 					container.appendChild(closeButton);
				// 				})
				// 				.catch((error) => {
				// 					console.error('无法访问摄像头:', error);
				// 					uni.showToast({
				// 						title: '无法访问摄像头',
				// 						icon: 'none',
				// 						duration: 2000
				// 					});
				// 				});
				// 		} else {
				// 			uni.showToast({
				// 				title: '您的设备不支持摄像头访问',
				// 				icon: 'none',
				// 				duration: 2000
				// 			});
				// 		}
			},
			withdraw(item) {
				let _ = this;
				const currentTime = Date.now();
				const messageTime = parseInt(item.time);
				const oneMinute = config.minute; // 60 * 1000 milliseconds

				if (currentTime < (messageTime + oneMinute)) {

					uni.showModal({
						title: '提示',
						content: '确认删除该条信息吗？',
						success: function(res) {
							if (res.confirm) {
								// 执行确认后的操作
								if (_.canwithdraw(item)) {

									const messageData = {
										sn: uuidv4(),
										group_name: _.groupName,
										avatar: _.user.avatar_url,
										content: item.sn,
										user_name: _.user.username,
										type: 'widthdraw',
										fid: _.user.id,
										tid: _.tid,
										created_at: _.getCurrentTimeToMinute(),
										receiver_type: _.receiver_type
									};
									_.socket.emit('sendMessage', messageData);
								} else {
									uni.showToast({
										title: '超过一分钟不能撤回',
										icon: 'none'
									});
								}


							} else {
								// 执行取消后的操作
							}
						}
					});
				}
			},

			canwithdraw(item) {
				const currentTime = Date.now();
				const messageTime = parseInt(item.time);
				const oneMinute = config.minute; // 60 * 1000 milliseconds

				if (currentTime > (messageTime + oneMinute)) {
					return false;
				} else {
					return true;
				}

			},


			getCurrentTimeToMinute() {
				const now = new Date();

				// 使用 Intl.DateTimeFormat 格式化日期和时间
				const dateFormatter = new Intl.DateTimeFormat('default', {
					year: 'numeric',
					month: '2-digit',
					day: '2-digit',
					hour: '2-digit',
					minute: '2-digit',
					hour12: false
				});

				// 格式化日期时间并返回
				return dateFormatter.format(now).replace(',', '');
			},

			async checkFriend(id) {
				const token = uni.getStorageSync('token');
				if (!token) return;
				let data = {
					id
				};
				try {
					const [error, response] = await uni.request({
						url: `${config.apiBaseUrl}/checkFriend`,
						method: 'GET',
						header: {
							Authorization: `Bearer ${token}`
						},
						data: {
							Id: id
						}
					});
					if (error) {
						throw new Error(`Request failed with error: ${error}`);
					}
					if (response.data.code === 0) {
						return true;
					} else {
						return false;
					}
				} catch (error) {
					return false;
				}
			},

			joinGroup() {
				this.socket.emit('joinGroup', {
					groupName: this.groupName,
					userName: this.user.username,
					userId: this.user.id
				});
			},

			tapTo(state) {
				let message = this.inputValue;
				if (message == '') {
					uni.showToast({
						title: '请输入聊天内容',
						icon: 'error'
					});
					return;
				}
				this.sendMessage(message);
			},

			getInput(e) {
				this.inputValue = e.detail.value;
			},

			initChatLog() {
				console.log('-initChatLog-')
				let _ = this;
				this.list = [];
				//接口 group 提交id 获取到群的信息
				const token = uni.getStorageSync('token');
				return new Promise((resolve, reject) => {
					uni.request({
						url: `${config.apiBaseUrl}/getMessages`,
						method: 'GET',
						header: {
							Authorization: `Bearer ${token}`
						},
						data: {
							receiver_type: _.receiver_type,
							tid: _.to_id   // 修复Bug, 原来这里写的是 _.tid
						},
						success: (res) => {
							resolve(res)
							console.log('-getMessages-')
							console.log(res.data.data.messages)
							this.list = res.data.data.messages
							this.list.forEach((item, index) => {
								this.list[index].isMe = item.fid == this.user.id ? true :
								false;
								this.list[index].toid = item.fid
							});
						},
						fail: (err) => {
							reject(err)
						}
					});
				})
			},
			async sendMessage(message, type = 'text') {
				this.$refs.popup.close();
				const messageData = {
					sn: uuidv4(),
					group_name: this.groupName,
					avatar: this.user.avatar_url,
					content: message,
					user_name: this.user.username,
					type: type,
					fid: this.user.id,
					tid: this.to_id, // 原来this.tid写错了  
					created_at: this.getCurrentTimeToMinute(),
					receiver_type: this.receiver_type
				};
				this.socket.emit('sendMessage', messageData);
				this.inputValue = '';

				if (type == 'image' || type == 'audio' || type == 'video' || type == 'text') {
					const token = uni.getStorageSync('token');
					try {
						const [error, response] = await uni.request({
							url: `${config.apiBaseUrl}/addmessage`,
							method: 'POST',
							header: {
								Authorization: `Bearer ${token}`
							},
							data: messageData
						});
						if (error) {
							throw new Error(`Request failed with error: ${error}`);
						}
					} catch (error) {}
				}


				this.$nextTick(() => {
					this.setScrollTop();
				});
			},
			async kickUser(name, type = 'kick') {
				console.log("groupname", this.groupName)
				console.log("name", name)
				console.log("type", type)
				if (type == 'kick') {

					this.socket.emit('kickUser', {
						groupName: this.type == 'group' ? this.groupName : this.groupName.replace('g_', ''),
						userName: name
					});

				} else {
					this.socket.emit('kickUser', {
						groupName: this.type == 'group' ? this.groupName : this.groupName.replace('g_', ''),
						userName: name
					});

					//拉黑
					let group_id = this.groupName.replace('g_', '')
					if (this.type != 'group') {
						group_id = 0

					}

					//调用black接口进行拉黑，拦黑完成让界面跳到friends

					const token = uni.getStorageSync('token');
					try {
						const [error, response] = await uni.request({
							url: `${config.apiBaseUrl}/black`,
							method: 'POST',
							header: {
								Authorization: `Bearer ${token}`
							},
							data: {
								name,
								group_id
							}
						});
						if (error) {
							throw new Error(`Request failed with error: ${error}`);
						}
						if (response.data.data.code == 0) {
							if (this.type == 'user') {
								uni.navigateTo({
									url: '/pages/index/friends'
								})
							}

						}
					} catch (error) {}

				}


			},
			setScrollTop() {
				this.$nextTick(() => {
					let query = uni.createSelectorQuery().in(this);
					query
						.select('.scroll-view')
						.boundingClientRect((rect) => {
							if (rect) {
								this.scrollHeight = rect.height;
							}
						})
						.exec();
				});
			},
			chooseFile() {

				// 检查是否为PC端
				const isPC = /Windows|Mac|Linux/.test(navigator.userAgent);
				
				if (isPC) {
					// PC端，调用摄像头拍照
					if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
						navigator.mediaDevices.getUserMedia({ video: true })
							.then((stream) => {
								// 创建视频元素
								const video = document.createElement('video');
								video.srcObject = stream;
								video.autoplay = true;
								
								// 创建容器
								const container = document.createElement('div');
								container.style.position = 'fixed';
								container.style.top = '0';
								container.style.left = '0';
								container.style.width = '100%';
								container.style.height = '100%';
								container.style.backgroundColor = 'rgba(0,0,0,0.8)';
								container.style.zIndex = '9999';
								
								container.appendChild(video);
								document.body.appendChild(container);
								
								// 添加拍照按钮
								const captureButton = document.createElement('button');
								captureButton.textContent = '拍照';
								captureButton.style.position = 'absolute';
								captureButton.style.bottom = '10px';
								captureButton.style.left = '30%';
								captureButton.style.transform = 'translateX(-50%)';
								captureButton.onclick = () => {
									// 创建canvas并捕获当前视频帧
									const canvas = document.createElement('canvas');
									canvas.width = video.videoWidth;
									canvas.height = video.videoHeight;
									canvas.getContext('2d').drawImage(video, 0, 0, canvas.width, canvas.height);
									
									// 将canvas转换为Blob
									canvas.toBlob((blob) => {
										// 停止所有视频轨道
										stream.getTracks().forEach(track => track.stop());
										
										// 移除容器
										document.body.removeChild(container);
										
										// 创建临时URL并上传
										const imageUrl = URL.createObjectURL(blob);
										this.selectedFilePath = imageUrl;
										this.uploadAvatar('image');
										
										// 清理临时URL
										URL.revokeObjectURL(imageUrl);
									}, 'image/jpeg');
								};
								container.appendChild(captureButton);
								
								// 添加取消按钮
								const cancelButton = document.createElement('button');
								cancelButton.textContent = '取消';
								cancelButton.style.position = 'absolute';
								cancelButton.style.bottom = '10px';
								cancelButton.style.left = '70%';
								cancelButton.style.transform = 'translateX(-50%)';
								cancelButton.onclick = () => {
									// 停止所有视频轨道
									stream.getTracks().forEach(track => track.stop());
									
									// 移除容器
									document.body.removeChild(container);
									
									// 继续执行选择文件的逻辑
									this.showFileChooseOptions();
								};
								container.appendChild(cancelButton);
							})
							.catch((error) => {
								console.error('无法访问摄像头:', error);
								uni.showToast({
									title: '无法访问摄像头',
									icon: 'none'
								});
								// 如果无法访问摄像头，继续执行选择文件的逻辑
								this.showFileChooseOptions();
							});
					} else {
						uni.showToast({
							title: '您的设备不支持摄像头',
							icon: 'none'
						});
						// 如果设备不支持摄像头，继续执行选择文件的逻辑
						this.showFileChooseOptions();
					}
				} else {
					// 非PC端，直接执行选择文件的逻辑
					this.showFileChooseOptions();
				}

			
			},

			showFileChooseOptions(){
				uni.showActionSheet({
					itemList: ['拍照', '从相册选择'],
					success: (res) => {
						if (res.tapIndex === 0) {
							this.takePhoto();
						} else if (res.tapIndex === 1) {
							this.selectImage();
						}
					},
					fail: (error) => {
						console.error('Failed to show action sheet:', error);
						uni.showToast({
							title: '操作失败',
							icon: 'none'
						});
					}
				});},
			takePhoto() {
				uni.chooseImage({
					count: 1,
					sourceType: ['camera'],
					success: async (res) => {
						this.selectedFilePath = res.tempFilePaths[0];
						await this.uploadAvatar('image');
					},
					fail: (error) => {
						console.error('Failed to take photo:', error);
						uni.showToast({
							title: '拍照失败',
							icon: 'none'
						});
					}
				});
			},
			selectImage() {
				uni.chooseImage({
					count: 1,
					sourceType: ['album'],
					success: async (res) => {
						this.selectedFilePath = res.tempFilePaths[0];
						await this.uploadAvatar('image');
					},
					fail: (error) => {
						console.error('Failed to select image:', error);
						uni.showToast({
							title: '选择图片失败',
							icon: 'none'
						});
					}
				});
			},
			previewImage(url) {
				uni.previewImage({
					urls: [url] // 需要预览的图片http链接列表
				});
			},
			async uploadAvatar(type) {
				if (!this.selectedFilePath) {
					uni.showToast({
						title: '请选择文件',
						icon: 'none'
					});
					return;
				}

				const token = uni.getStorageSync('token');
				uni.uploadFile({
					url: `${config.apiBaseUrl}/upload`,
					filePath: this.selectedFilePath,
					name: 'avatar',
					header: {
						Authorization: `Bearer ${token}`
					},
					success: async (uploadFileRes) => {
						const response = JSON.parse(uploadFileRes.data);
						if (response.code == 0) {
							const avatarUrl = response.data;
							this.sendMessage(avatarUrl, type);
						}
					},
					fail: (error) => {
						console.error('Failed to upload avatar:', error);
						uni.showToast({
							title: '上传失败',
							icon: 'none'
						});
					}
				});
			},
		copyBtnClick(data) {
			 handleClipboard( // 这是 实现向剪切板 写入内容的代码， data 就是传入的要写入剪切板的内容
			        // 写入剪切板
			        data,  
			        event,
			        () => {
			          uni.showToast({
			            title: '已复制到剪切板',
			          });
			        },
			        () => {
			          uni.showToast({
			            title: '复制失败',
			          });
			        }
			  );
		},
		formatMessage(content) {
			// Detect URLs and format them as links
			const urlRegex = /(https?:\/\/[^\s]+)/g;
			content = content.replace(urlRegex, '<a href="$1" target="_blank" style="color:blue;">$1</a>');
			return content.replace(/\n/g, '<br>');

		},
		detectCode(content) {
			// Basic check to see if the content is likely code (this can be improved)
			const codeKeywords = ['function', 'const', 'let', 'var', 'if', 'else', '{', '}', '=', '=>'];
			return codeKeywords.some(keyword => content.includes(keyword)) || /[<>&]/.test(content);
		},
		escapeHtml(content) {
			// Escape HTML to prevent it from being rendered as actual HTML
			return content
				.replace(/&/g, "&amp;")
				.replace(/</g, "&lt;")
				.replace(/>/g, "&gt;");
		}
	}
	};
</script>
<style lang="scss" scoped>
	@import url('static/iconfont.css');

	.base-btn {
		position: fixed;
		width: 100%;
		height: 50px;
		bottom: var(--window-bottom);
		left: 0;
		justify-content: space-between;
		background-color: #ffffff;
		transition: bottom 0.3s;
	}

	.base-btn-popup-open {
		bottom: 200rpx;
		/* 调整为 popup 高度 */
	}

	.base-con {
		margin-top: 7.5px;
		display: flex;
		height: inherit;
		align-items: center;
		justify-content: space-between;
	}

	.send-image {
		width: 35px;
		line-height: 35px;
		background-color: #ffb967;
		border-radius: 50%;
		text-align: center;
		color: #ffffff;
		font-size: 30rpx;
	}

	.input-text {
		width: 58%;
		height: 35px;
		background-color: #f2f2f2;
		border-radius: 8px;
		padding: 0 15px;
	}

	.send-input {
		width: 64px;
		line-height: 35px;
		text-align: center;
		background-color: #ffb967;
		border-radius: 8px;
		color: #ffffff;
	}

	.scroll-view,
	.base-con {
		margin: 0 15px;
	}

	.avatar {
		width: 32px;
		height: 32px;
		border-radius: 50%;
		float: left;
		margin-top: 20px;
	}

	.avatar-right {
		margin-right: 10px;
	}

	.message-box {
		max-width: 76%;
		display: inline-block;
		word-wrap: break-word;
		/* 控制消息框换行 */
	}

	.message {
		font-size: 30rpx;
		background-color: #e6e6e6;
		padding: 10px;
		float: left;
		border-radius: 8px;
		overflow: hidden;
		word-break: break-all;
		white-space: pre-wrap;
		margin-top: 10px;
		width: 100%;
	}

	.message_img {
		font-size: 0rpx;
		background-color: lightgray;
		padding: 10px;
		float: left;
		border-radius: 8px;
		overflow: hidden;
		word-break: break-all;
		white-space: pre-wrap;
		margin-top: 5px;
	}

	.message-image {
		width: 80px;
		height: 130px;
		padding: 15px 0;
		border-radius: 8px;
		overflow: hidden;
	}

	.news-box::after {
		content: '';
		display: block;
		clear: both;
	}

	.news-box:last-child .message {
		margin-bottom: 20px;
	}

	.is-me {
		float: right;
		margin-left: 10px;
	}

	.message-type {
		text-align: center;
		color: #aaa;
		/* 字体颜色变淡 */
		font-size: 20rpx;
		/* 字体小一号 */
		margin-top: 10px;
	}

	.group-box {
		color: #727172;
		/* 字体颜色变淡 */
		font-size: 26rpx;
		/* 字体小一号 */
		margin: 6px 0 0 6px;
	}

	.group-member {
		margin-right: 4px;
	}

	.popup-content {
		display: flex;
		justify-content: center;
		/* 居中对齐内容 */
		align-items: center;
		/* 垂直居中对齐 */
	}

	.popup-items {
		display: flex;
		width: 100%;
		flex-wrap: wrap;
		/* 允许换行 */
		justify-content: space-around;
		/* 平均分配空间 */
		padding: 10rpx;
		/* 可选的内边距 */
	}

	.popup-item {
		flex: 1 1 10%;
		/* 每个图片占据 20% 的宽度，支持换行 */
		display: flex;
		flex-direction: column;
		/* 垂直布局 */
		justify-content: center;
		align-items: center;
		margin: 5rpx;
		/* 图片间距 */
	}

	.popup-image {
		width: 80%;
		/* 图片宽度占父容器的 80% */
		height: auto;
		/* 高度自动，以保持宽高比 */
		object-fit: cover;
		/* 确保图片在框中完全填充 */
	}

	.username {
		font-size: 20rpx;
		color: #666;
		margin-top: 5px;
		text-align: center;
	}
</style>

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2156815.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2024 离线ASR和TTS推荐与示例

2024 离线ASR和TTS推荐与示例

2024 离线ASR和TTS推荐 文章目录 2024 离线ASR和TTS推荐一、前言二、安装与使用1、EdgeTTS的安装和使用&#xff08;1&#xff09;Edge TTS介绍与效果试听&#xff08;2&#xff09;Edge TTS安装&#xff08;3&#xff09;Edge TTS查看支持的音色&#xff08;4&#xff09;Edge…
阅读更多...
16【Protues51单片机仿真】智能洗衣机倒计时系统

16【Protues51单片机仿真】智能洗衣机倒计时系统

目录 一、主要功能 二、硬件资源 三、程序编程 四、实现现象 一、主要功能 用直流电机转动模拟洗衣机。要求 有弱洗、普通洗、强洗三种模式&#xff0c;可通过按键选择。可以设置洗衣时长&#xff0c;通关按键选择15、30、45、60、90分钟。时间到蜂鸣器报警提示。LCD 显示…
阅读更多...
MySQL：事务的ACID特性隔离级别脏读/不可重复读/幻读/Next-Key锁——场景复现

MySQL：事务的ACID特性隔离级别脏读/不可重复读/幻读/Next-Key锁——场景复现

目录 1、什么是事务 2、 事务的ACID特性 2.1 事务的隔离性 3、为什么要使用事务&#xff1f; 4、查看支持事务的存储引擎 5、使用事务 5.1 控制事务 5.1.1 开启事务 5.1.2 关闭事务 5.2 开始一个事务&#xff0c;执行修改后回滚 5.3 开始一个事务&#xff0c;执行修…
阅读更多...
set-ExecutionPolicy RemoteSigned 提示不是内部或外部命令，也不是可运行的程序或批处理文件

set-ExecutionPolicy RemoteSigned 提示不是内部或外部命令，也不是可运行的程序或批处理文件

这个错误一般发生在使用命令提示符或者PowerShell窗口中找不到set-ExecutionPolicy RemoteSigned。如果你想在命令提示符或者PowerShell窗口运行set-ExecutionPolicy RemoteSigned&#xff0c;你需要搜索打开Window PowerShell ISE&#xff0c;并以管理员身份打开&#xff0c;输…
阅读更多...
图结构感知的Transformer：一种新的图表示学习方法

图结构感知的Transformer：一种新的图表示学习方法

人工智能咨询培训老师叶梓 转载标明出处 尽管图神经网络&#xff08;GNNs&#xff09;在处理图数据方面取得了显著成就&#xff0c;但它们在表达能力和捕获长距离依赖方面存在局限性。为了突破这些局限&#xff0c;研究者们开始探索将Transformer架构应用于图表示学习。在此基…
阅读更多...
使用Electron打包一个Vue3项目全步骤

使用Electron打包一个Vue3项目全步骤

1.创建一个Vue3项目 2.使用 WebStorm打开项目&#xff0c;并安装依赖项 npm install 等待完成后&#xff0c; 安装electron npm install --save-dev electron 等待完成后&#xff0c; 安装electron 打包依赖项(打包成可执行文件) npm install electron-packager --save-dev 3…
阅读更多...
从零开始一个git操作实例，图文并茂

从零开始一个git操作实例，图文并茂

徒弟不懂git怎么用&#xff0c; 于是写了篇文章&#xff0c; 把本地git操作从头写了一遍&#xff0c; 自己去看吧&#xff01; 0、基本概念 •Git是一个免费、开源的、分布式版本控制系统 •它使用一个特殊的叫做仓库的数据库来记录文件的变化 •仓库中的每个文件都有一个…
阅读更多...
ccfcsp-202406（1、2、3、4、5）

ccfcsp-202406（1、2、3、4、5）

矩阵重塑&#xff08;其一&#xff09; #include <bits/stdc.h> using namespace std; int main() {int n,m,p,q;cin >> n >> m >> p >> q;vector<int> vec(n * m);vector<vector<int>> res(p, vector(q,0));int k 0;for(in…
阅读更多...
力扣反转链表系列【25. K 个一组翻转链表】——由易到难，一次刷通！！！

力扣反转链表系列【25. K 个一组翻转链表】——由易到难，一次刷通！！！

力扣《反转链表》系列文章目录 刷题次序&#xff0c;由易到难&#xff0c;一次刷通&#xff01;&#xff01;&#xff01; 题目题解206. 反转链表反转链表的全部 题解192. 反转链表 II反转链表的指定段 题解224. 两两交换链表中的节点两个一组反转链表 题解325. K 个一组翻转…
阅读更多...
HarmonyOS---权限和http/Axios网络请求

HarmonyOS---权限和http/Axios网络请求

网络请求(http,axios) 目录 一、应用权限管理1.1权限的等级1.2授权方式1.3声明权限的配置1.4如何向用户进行申请 二、内置http请求使用三、Axios请求使用&#xff08;建议&#xff09;3.1 使用方式一3.2 使用方式二&#xff08;建议&#xff09; 一、应用权限管理 应用权限保护…
阅读更多...
git仓库服务器端损坏如何用本地code重新部署

git仓库服务器端损坏如何用本地code重新部署

文章目录 1. **在新服务器上创建一个新的 Git 仓库**2. **将本地仓库推送到新服务器**2.1. 添加新服务器为远程仓库2.2. 推送代码和历史记录2.3. 推送 tags&#xff08;如果有 tags&#xff09; 3. **在新服务器上拉取代码并部署**4. **确保修改记录和历史完整**5. **可选&…
阅读更多...
Flink Task 日志文件隔离

Flink Task 日志文件隔离

Flink Task 日志文件隔离 任务在启动时会先通过 MdcUtils 启动一个 slf4j 的 MDC 环境&#xff0c;然后将 jobId 添加到 slf4j 的 MDC 容器中&#xff0c;随后任务输出的日志都将附带 joid。 MDC 介绍如下&#xff1a; MDC ( Mapped Diagnostic Contexts )&#xff0c;它是一个…
阅读更多...
Linux 线程互斥

Linux 线程互斥

文章目录 3. Linux 线程互斥3.1 相关概念3.2 互斥量mutex3.3 互斥量的接口3.4 改进3.2中的代码3.5 互斥量&#xff08;锁&#xff09;的原理3.6 封装一下原生锁的接口&#xff0c;RAII风格的锁3.7 可重入 和 线程安全 3. Linux 线程互斥 3.1 相关概念 临界资源&#xff1a;多…
阅读更多...
web自动化学习笔记

web自动化学习笔记

目录 一、web自动化测试环境搭建二、web自动化测试第一个脚本三、selenium 8种定位方式3.1、通过id定位3.2、通过name定位3.3、通过tag_name&#xff08;标签名&#xff09;定位3.4、通过class值进行定位3.5、通过链接文本定位3.6、通过部分链接文本定位3.7、通过xpath定位3.8、…
阅读更多...
MySQL：SQL语句执行过程

MySQL：SQL语句执行过程

本篇文章会分析下一个 SQL 语句在 MySQL 中的执行流程&#xff0c;包括 SQL 的查询在 MySQL 内部会怎么流转&#xff0c;SQL 语句的更新是怎么完成的。 在分析之前我会先带着你看看 MySQL 的基础架构&#xff0c;知道了 MySQL 由那些组件组成以及这些组件的作用是什么&#xf…
阅读更多...
Spring_AMQP

Spring_AMQP

文章目录 一、SpringAMQP二、SpringAMQP应用2.1、消息发送2.2、消息接收 一、SpringAMQP SpringAMQP是基于RabbitMQ封装的一套模板&#xff0c;并且还利用SpringBoot对其实现了自动装配&#xff0c;使用起来非常方便。 SpringAmqp的官方地址。 SpringAMQP提供了三个功能&am…
阅读更多...
python27 安装pywinauto-0.6.8

python27 安装pywinauto-0.6.8

文章目录 环境所需依赖依赖查找所需依赖链接1. comtypes2. six3. pyWin324. (optional) Pillow (to make screenshoots)5. pywinauto 安装结果 环境 windows 11 Python 2.7 setuptools 18.0.1 pip 18.1 所需依赖 依赖查找 按照官方文档&#xff08;https://pywinauto.readt…
阅读更多...
MMROTATE 1.X特征图可视化（绘制Heat Map）

MMROTATE 1.X特征图可视化（绘制Heat Map）

本文参考MMYOLO官方的特征图可视化教程&#xff0c;对MMROTATE相关算法进行特征图可视化 1. 新建featmap_vis_demo.py文件 在mmrotate项目文件夹下新建 featmap_vis_demo.py &#xff1a; # Copyright (c) OpenMMLab. All rights reserved. import argparse import os from t…
阅读更多...
java intellij idea开发步骤，使用指南，工程创建与背景色字体配置，快捷键

java intellij idea开发步骤，使用指南，工程创建与背景色字体配置，快捷键

intellij idea2021 配置背景色&#xff0c;字体大小&#xff0c;主题 快捷键
阅读更多...
STM32系统时钟

STM32系统时钟

时钟为单片机提供了稳定的机器周期&#xff0c;从而使我们的系统能够正常的运行 时钟就像我们人的心脏&#xff0c;一旦有问题就整个都会崩溃 stm32有很多外设&#xff0c;但不是所有的外设都使用同一种时钟频率工作&#xff0c;比如我们的内部看门狗和RTC 只要30几k的频率就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023