code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package com.hmall.item.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 商品表
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("item")
public class Item implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 商品id
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* SKU名称
*/
private String name;
/**
* 价格（分）
*/
private Integer price;
/**
* 库存数量
*/
private Integer stock;
/**
* 商品图片
*/
private String image;
/**
* 类目名称
*/
private String category;
/**
* 品牌名称
*/
private String brand;
/**
* 规格
*/
private String spec;
/**
* 销量
*/
private Integer sold;
/**
* 评论数
*/
private Integer commentCount;
/**
* 是否是推广广告，true/false
*/
@TableField("isAD")
private Boolean isAD;
/**
* 商品状态 1-正常，2-下架，3-删除
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 创建人
*/
private Long creater;
/**
* 修改人
*/
private Long updater;
}
|
2201_75631765/hmall
|
item-service/src/main/java/com/hmall/item/domain/po/Item.java
|
Java
|
unknown
| 1,808
|
package com.hmall.item.domain.query;
import com.hmall.common.domain.PageQuery;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(description = "商品分页查询条件")
public class ItemPageQuery extends PageQuery {
@ApiModelProperty("搜索关键字")
private String key;
@ApiModelProperty("商品分类")
private String category;
@ApiModelProperty("商品品牌")
private String brand;
@ApiModelProperty("价格最小值")
private Integer minPrice;
@ApiModelProperty("价格最大值")
private Integer maxPrice;
}
|
2201_75631765/hmall
|
item-service/src/main/java/com/hmall/item/domain/query/ItemPageQuery.java
|
Java
|
unknown
| 704
|
package com.hmall.item.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.api.dto.OrderDetailDTO;
import com.hmall.item.domain.po.Item;
import org.apache.ibatis.annotations.Update;
/**
* <p>
* 商品表 Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface ItemMapper extends BaseMapper<Item> {
@Update("UPDATE item SET stock = stock - #{num} WHERE id = #{itemId}")
void updateStock(OrderDetailDTO orderDetail);
}
|
2201_75631765/hmall
|
item-service/src/main/java/com/hmall/item/mapper/ItemMapper.java
|
Java
|
unknown
| 488
|
package com.hmall.item.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.api.dto.ItemDTO;
import com.hmall.api.dto.OrderDetailDTO;
import com.hmall.item.domain.po.Item;
import java.util.Collection;
import java.util.List;
/**
* <p>
* 商品表 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IItemService extends IService<Item> {
void deductStock(List<OrderDetailDTO> items);
List<ItemDTO> queryItemByIds(Collection<Long> ids);
}
|
2201_75631765/hmall
|
item-service/src/main/java/com/hmall/item/service/IItemService.java
|
Java
|
unknown
| 514
|
package com.hmall.item.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.api.dto.ItemDTO;
import com.hmall.api.dto.OrderDetailDTO;
import com.hmall.common.exception.BizIllegalException;
import com.hmall.common.utils.BeanUtils;
import com.hmall.item.domain.po.Item;
import com.hmall.item.mapper.ItemMapper;
import com.hmall.item.service.IItemService;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
/**
* <p>
* 商品表 服务实现类
* </p>
*
* @author 虎哥
*/
@Service
public class ItemServiceImpl extends ServiceImpl<ItemMapper, Item> implements IItemService {
@Override
public void deductStock(List<OrderDetailDTO> items) {
String sqlStatement = "com.hmall.item.mapper.ItemMapper.updateStock";
boolean r = false;
try {
r = executeBatch(items, (sqlSession, entity) -> sqlSession.update(sqlStatement, entity));
} catch (Exception e) {
throw new BizIllegalException("更新库存异常，可能是库存不足!", e);
}
if (!r) {
throw new BizIllegalException("库存不足！");
}
}
@Override
public List<ItemDTO> queryItemByIds(Collection<Long> ids) {
return BeanUtils.copyList(listByIds(ids), ItemDTO.class);
}
}
|
2201_75631765/hmall
|
item-service/src/main/java/com/hmall/item/service/impl/ItemServiceImpl.java
|
Java
|
unknown
| 1,356
|
package com.hmall.pay;
/**
* author Link
*
* @version 1.0
* @date 2025/3/12 10:27
*/
import com.hmall.api.config.DefaultFeignConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@EnableFeignClients(basePackages = "com.hmall.api.client", defaultConfiguration = DefaultFeignConfig.class)
@MapperScan("com.hmall.pay.mapper")
@SpringBootApplication
public class PayApplication {
public static void main(String[] args) {
SpringApplication.run(PayApplication.class, args);
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/PayApplication.java
|
Java
|
unknown
| 682
|
package com.hmall.pay.controller;
import com.hmall.common.exception.BizIllegalException;
import com.hmall.common.utils.BeanUtils;
import com.hmall.pay.domain.dto.PayApplyDTO;
import com.hmall.pay.domain.dto.PayOrderFormDTO;
import com.hmall.pay.domain.vo.PayOrderVO;
import com.hmall.pay.enums.PayType;
import com.hmall.pay.service.IPayOrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Api(tags = "支付相关接口")
@RestController
@RequestMapping("pay-orders")
@RequiredArgsConstructor
public class PayController {
private final IPayOrderService payOrderService;
@ApiOperation("生成支付单")
@PostMapping
public String applyPayOrder(@RequestBody PayApplyDTO applyDTO){
if(!PayType.BALANCE.equalsValue(applyDTO.getPayType())){
// 目前只支持余额支付
throw new BizIllegalException("抱歉，目前只支持余额支付");
}
return payOrderService.applyPayOrder(applyDTO);
}
@ApiOperation("尝试基于用户余额支付")
@ApiImplicitParam(value = "支付单id", name = "id")
@PostMapping("{id}")
public void tryPayOrderByBalance(@PathVariable("id") Long id, @RequestBody PayOrderFormDTO payOrderFormDTO){
payOrderFormDTO.setId(id);
payOrderService.tryPayOrderByBalance(payOrderFormDTO);
}
@ApiOperation("查询支付单")
@GetMapping
public List<PayOrderVO> queryPayOrders(){
return BeanUtils.copyList(payOrderService.list(), PayOrderVO.class);
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/controller/PayController.java
|
Java
|
unknown
| 1,703
|
package com.hmall.pay.domain.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
@Data
@Builder
@ApiModel(description = "支付下单表单实体")
public class PayApplyDTO {
@ApiModelProperty("业务订单id不能为空")
@NotNull(message = "业务订单id不能为空")
private Long bizOrderNo;
@ApiModelProperty("支付金额必须为正数")
@Min(value = 1, message = "支付金额必须为正数")
private Integer amount;
@ApiModelProperty("支付渠道编码不能为空")
@NotNull(message = "支付渠道编码不能为空")
private String payChannelCode;
@ApiModelProperty("支付方式不能为空")
@NotNull(message = "支付方式不能为空")
private Integer payType;
@ApiModelProperty("订单中的商品信息不能为空")
@NotNull(message = "订单中的商品信息不能为空")
private String orderInfo;
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/domain/dto/PayApplyDTO.java
|
Java
|
unknown
| 1,058
|
package com.hmall.pay.domain.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import javax.validation.constraints.NotNull;
@Data
@Builder
@ApiModel(description = "支付确认表单实体")
public class PayOrderFormDTO {
@ApiModelProperty("支付订单id不能为空")
@NotNull(message = "支付订单id不能为空")
private Long id;
@ApiModelProperty("支付密码")
@NotNull(message = "支付密码")
private String pw;
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/domain/dto/PayOrderFormDTO.java
|
Java
|
unknown
| 538
|
package com.hmall.pay.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 支付订单
* </p>
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("pay_order")
public class PayOrder implements Serializable {
private static final long serialVersionUID = 1L;
/**
* id
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id;
/**
* 业务订单号
*/
private Long bizOrderNo;
/**
* 支付单号
*/
private Long payOrderNo;
/**
* 支付用户id
*/
private Long bizUserId;
/**
* 支付渠道编码
*/
private String payChannelCode;
/**
* 支付金额，单位分
*/
private Integer amount;
/**
* 支付类型，1：h5,2:小程序，3：公众号，4：扫码，5：余额支付
*/
private Integer payType;
/**
* 支付状态，0：待提交，1:待支付，2：支付超时或取消，3：支付成功
*/
private Integer status;
/**
* 拓展字段，用于传递不同渠道单独处理的字段
*/
private String expandJson;
/**
* 第三方返回业务码
*/
private String resultCode;
/**
* 第三方返回提示信息
*/
private String resultMsg;
/**
* 支付成功时间
*/
private LocalDateTime paySuccessTime;
/**
* 支付超时时间
*/
private LocalDateTime payOverTime;
/**
* 支付二维码链接
*/
private String qrCodeUrl;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 创建人
*/
private Long creater;
/**
* 更新人
*/
private Long updater;
/**
* 逻辑删除
*/
private Boolean isDelete;
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/domain/po/PayOrder.java
|
Java
|
unknown
| 2,175
|
package com.hmall.pay.domain.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.time.LocalDateTime;
/**
* <p>
* 支付订单
* </p>
*/
@Data
@ApiModel(description = "支付单vo实体")
public class PayOrderVO {
@ApiModelProperty("id")
private Long id;
@ApiModelProperty("业务订单号")
private Long bizOrderNo;
@ApiModelProperty("支付单号")
private Long payOrderNo;
@ApiModelProperty("支付用户id")
private Long bizUserId;
@ApiModelProperty("支付渠道编码")
private String payChannelCode;
@ApiModelProperty("支付金额，单位分")
private Integer amount;
@ApiModelProperty("付类型，1：h5,2:小程序，3：公众号，4：扫码，5：余额支付")
private Integer payType;
@ApiModelProperty("付状态，0：待提交，1:待支付，2：支付超时或取消，3：支付成功")
private Integer status;
@ApiModelProperty("拓展字段，用于传递不同渠道单独处理的字段")
private String expandJson;
@ApiModelProperty("第三方返回业务码")
private String resultCode;
@ApiModelProperty("第三方返回提示信息")
private String resultMsg;
@ApiModelProperty("支付成功时间")
private LocalDateTime paySuccessTime;
@ApiModelProperty("支付超时时间")
private LocalDateTime payOverTime;
@ApiModelProperty("支付二维码链接")
private String qrCodeUrl;
@ApiModelProperty("创建时间")
private LocalDateTime createTime;
@ApiModelProperty("更新时间")
private LocalDateTime updateTime;
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/domain/vo/PayOrderVO.java
|
Java
|
unknown
| 1,657
|
package com.hmall.pay.enums;
import cn.hutool.core.util.StrUtil;
import lombok.Getter;
@Getter
public enum PayChannel {
wxPay("微信支付"),
aliPay("支付宝支付"),
balance("余额支付"),
;
private final String desc;
PayChannel(String desc) {
this.desc = desc;
}
public static String desc(String value){
if (StrUtil.isBlank(value)) {
return "";
}
return PayChannel.valueOf(value).getDesc();
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/enums/PayChannel.java
|
Java
|
unknown
| 487
|
package com.hmall.pay.enums;
import lombok.Getter;
@Getter
public enum PayStatus {
NOT_COMMIT(0, "未提交"),
WAIT_BUYER_PAY(1, "待支付"),
TRADE_CLOSED(2, "已关闭"),
TRADE_SUCCESS(3, "支付成功"),
TRADE_FINISHED(3, "支付成功"),
;
private final int value;
private final String desc;
PayStatus(int value, String desc) {
this.value = value;
this.desc = desc;
}
public boolean equalsValue(Integer value){
if (value == null) {
return false;
}
return getValue() == value;
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/enums/PayStatus.java
|
Java
|
unknown
| 587
|
package com.hmall.pay.enums;
import lombok.Getter;
@Getter
public enum PayType{
JSAPI(1, "网页支付JS"),
MINI_APP(2, "小程序支付"),
APP(3, "APP支付"),
NATIVE(4, "扫码支付"),
BALANCE(5, "余额支付"),
;
private final int value;
private final String desc;
PayType(int value, String desc) {
this.value = value;
this.desc = desc;
}
public boolean equalsValue(Integer value){
if (value == null) {
return false;
}
return getValue() == value;
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/enums/PayType.java
|
Java
|
unknown
| 560
|
package com.hmall.pay.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.pay.domain.po.PayOrder;
/**
* <p>
* 支付订单 Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-16
*/
public interface PayOrderMapper extends BaseMapper<PayOrder> {
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/mapper/PayOrderMapper.java
|
Java
|
unknown
| 291
|
package com.hmall.pay.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.pay.domain.dto.PayApplyDTO;
import com.hmall.pay.domain.dto.PayOrderFormDTO;
import com.hmall.pay.domain.po.PayOrder;
/**
* <p>
* 支付订单 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-16
*/
public interface IPayOrderService extends IService<PayOrder> {
String applyPayOrder(PayApplyDTO applyDTO);
void tryPayOrderByBalance(PayOrderFormDTO payOrderFormDTO);
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/service/IPayOrderService.java
|
Java
|
unknown
| 499
|
package com.hmall.pay.service.impl;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.api.client.TradeClient;
import com.hmall.api.client.UserClient;
import com.hmall.common.exception.BizIllegalException;
import com.hmall.common.utils.BeanUtils;
import com.hmall.common.utils.UserContext;
import com.hmall.pay.domain.dto.PayApplyDTO;
import com.hmall.pay.domain.dto.PayOrderFormDTO;
import com.hmall.pay.domain.po.PayOrder;
import com.hmall.pay.enums.PayStatus;
import com.hmall.pay.mapper.PayOrderMapper;
import com.hmall.pay.service.IPayOrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
/**
* <p>
* 支付订单 服务实现类
* </p>
*
* @author 虎哥
* @since 2023-05-16
*/
@Service
@RequiredArgsConstructor
public class PayOrderServiceImpl extends ServiceImpl<PayOrderMapper, PayOrder> implements IPayOrderService {
//private final IUserService userService;
private final UserClient userClient;
//private final IOrderService orderService;
private final TradeClient tradeClient;
@Override
public String applyPayOrder(PayApplyDTO applyDTO) {
// 1.幂等性校验
PayOrder payOrder = checkIdempotent(applyDTO);
// 2.返回结果
return payOrder.getId().toString();
}
@Override
@Transactional
public void tryPayOrderByBalance(PayOrderFormDTO payOrderFormDTO) {
// 1.查询支付单
PayOrder po = getById(payOrderFormDTO.getId());
// 2.判断状态
if(!PayStatus.WAIT_BUYER_PAY.equalsValue(po.getStatus())){
// 订单不是未支付，状态异常
throw new BizIllegalException("交易已支付或关闭！");
}
// 3.尝试扣减余额
userClient.deductMoney(payOrderFormDTO.getPw(), po.getAmount());
// 4.修改支付单状态
boolean success = markPayOrderSuccess(payOrderFormDTO.getId(), LocalDateTime.now());
if (!success) {
throw new BizIllegalException("交易已支付或关闭！");
}
// 5.修改订单状态
tradeClient.markOrderPaySuccess(po.getBizOrderNo());
/*Order order = new Order();
order.setId(po.getBizOrderNo());
order.setStatus(2);
order.setPayTime(LocalDateTime.now());
orderService.updateById(order);*/
}
public boolean markPayOrderSuccess(Long id, LocalDateTime successTime) {
return lambdaUpdate()
.set(PayOrder::getStatus, PayStatus.TRADE_SUCCESS.getValue())
.set(PayOrder::getPaySuccessTime, successTime)
.eq(PayOrder::getId, id)
// 支付状态的乐观锁判断
.in(PayOrder::getStatus, PayStatus.NOT_COMMIT.getValue(), PayStatus.WAIT_BUYER_PAY.getValue())
.update();
}
private PayOrder checkIdempotent(PayApplyDTO applyDTO) {
// 1.首先查询支付单
PayOrder oldOrder = queryByBizOrderNo(applyDTO.getBizOrderNo());
// 2.判断是否存在
if (oldOrder == null) {
// 如果不存在，创建新订单
PayOrder payOrder = buildPayOrder(applyDTO);
// 不存在支付单，说明是第一次，写入新的支付单并返回
// 确保 biz_order_no 被正确赋值
if (applyDTO.getBizOrderNo() == null) {
throw new BizIllegalException("biz_order_no 不能为空");
}
payOrder.setBizOrderNo(applyDTO.getBizOrderNo()); // 显式设置 biz_order_no
payOrder.setPayOrderNo(IdWorker.getId());
save(payOrder);
return payOrder;
}
// 3.旧单已经存在，判断是否支付成功
if (PayStatus.TRADE_SUCCESS.equalsValue(oldOrder.getStatus())) {
// 已经支付成功，抛出异常
throw new BizIllegalException("订单已经支付！");
}
// 4.旧单已经存在，判断是否已经关闭
if (PayStatus.TRADE_CLOSED.equalsValue(oldOrder.getStatus())) {
// 已经关闭，抛出异常
throw new BizIllegalException("订单已关闭");
}
// 5.旧单已经存在，判断支付渠道是否一致
if (!StringUtils.equals(oldOrder.getPayChannelCode(), applyDTO.getPayChannelCode())) {
// 支付渠道不一致，需要重置数据，然后重新申请支付单
PayOrder payOrder = buildPayOrder(applyDTO);
payOrder.setId(oldOrder.getId());
payOrder.setQrCodeUrl("");
updateById(payOrder);
payOrder.setPayOrderNo(oldOrder.getPayOrderNo());
return payOrder;
}
// 6.旧单已经存在，且可能是未支付或未提交，且支付渠道一致，直接返回旧数据
return oldOrder;
}
private PayOrder buildPayOrder(PayApplyDTO payApplyDTO) {
// 1.数据转换
PayOrder payOrder = BeanUtils.toBean(payApplyDTO, PayOrder.class);
// 2.初始化数据
payOrder.setPayOverTime(LocalDateTime.now().plusMinutes(120L));
payOrder.setStatus(PayStatus.WAIT_BUYER_PAY.getValue());
payOrder.setBizUserId(UserContext.getUser());
return payOrder;
}
public PayOrder queryByBizOrderNo(Long bizOrderNo) {
return lambdaQuery()
.eq(PayOrder::getBizOrderNo, bizOrderNo)
.one();
}
}
|
2201_75631765/hmall
|
pay-service/src/main/java/com/hmall/pay/service/impl/PayOrderServiceImpl.java
|
Java
|
unknown
| 5,680
|
package com.hmall.trade;
import com.hmall.api.config.DefaultFeignConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* author Link
*
* @version 1.0
* @date 2025/3/12 8:30
*/
@SpringBootApplication
@MapperScan("com.hmall.trade.mapper")
@EnableFeignClients(basePackages = "com.hmall.api.client",defaultConfiguration = DefaultFeignConfig.class)
public class TradeApplication {
public static void main(String[] args) {
SpringApplication.run(TradeApplication.class,args);
}
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/TradeApplication.java
|
Java
|
unknown
| 687
|
package com.hmall.trade.controller;
import com.hmall.common.utils.BeanUtils;
import com.hmall.trade.domain.dto.OrderFormDTO;
import com.hmall.trade.domain.vo.OrderVO;
import com.hmall.trade.service.IOrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.apache.ibatis.annotations.Param;
import org.springframework.web.bind.annotation.*;
@Api(tags = "订单管理接口")
@RestController
@RequestMapping("/orders")
@RequiredArgsConstructor
public class OrderController {
private final IOrderService orderService;
@ApiOperation("根据id查询订单")
@GetMapping("{id}")
public OrderVO queryOrderById(@Param("订单id")@PathVariable("id") Long orderId) {
return BeanUtils.copyBean(orderService.getById(orderId), OrderVO.class);
}
@ApiOperation("创建订单")
@PostMapping
public Long createOrder(@RequestBody OrderFormDTO orderFormDTO){
return orderService.createOrder(orderFormDTO);
}
@ApiOperation("标记订单已支付")
@ApiImplicitParam(name = "orderId", value = "订单id", paramType = "path")
@PutMapping("/{orderId}")
public void markOrderPaySuccess(@PathVariable("orderId") Long orderId) {
orderService.markOrderPaySuccess(orderId);
}
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/controller/OrderController.java
|
Java
|
unknown
| 1,369
|
package com.hmall.trade.domain.dto;
import com.hmall.api.dto.OrderDetailDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.List;
@Data
@ApiModel(description = "交易下单表单实体")
public class OrderFormDTO {
@ApiModelProperty("收货地址id")
private Long addressId;
@ApiModelProperty("支付类型")
private Integer paymentType;
@ApiModelProperty("下单商品列表")
private List<OrderDetailDTO> details;
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/domain/dto/OrderFormDTO.java
|
Java
|
unknown
| 526
|
package com.hmall.trade.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
*
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("`order`")
public class Order implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 订单id
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id;
/**
* 总金额，单位为分
*/
private Integer totalFee;
/**
* 支付类型，1、支付宝，2、微信，3、扣减余额
*/
private Integer paymentType;
/**
* 用户id
*/
private Long userId;
/**
* 订单的状态，1、未付款 2、已付款,未发货 3、已发货,未确认 4、确认收货，交易成功 5、交易取消，订单关闭 6、交易结束，已评价
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 支付时间
*/
private LocalDateTime payTime;
/**
* 发货时间
*/
private LocalDateTime consignTime;
/**
* 交易完成时间
*/
private LocalDateTime endTime;
/**
* 交易关闭时间
*/
private LocalDateTime closeTime;
/**
* 评价时间
*/
private LocalDateTime commentTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/domain/po/Order.java
|
Java
|
unknown
| 1,728
|
package com.hmall.trade.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 订单详情表
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("order_detail")
public class OrderDetail implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 订单详情id
*/
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 订单id
*/
private Long orderId;
/**
* sku商品id
*/
private Long itemId;
/**
* 购买数量
*/
private Integer num;
/**
* 商品标题
*/
private String name;
/**
* 商品动态属性键值集
*/
private String spec;
/**
* 价格,单位：分
*/
private Integer price;
/**
* 商品图片
*/
private String image;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/domain/po/OrderDetail.java
|
Java
|
unknown
| 1,349
|
package com.hmall.trade.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
*
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("order_logistics")
public class OrderLogistics implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 订单id，与订单表一对一
*/
@TableId(value = "order_id", type = IdType.INPUT)
private Long orderId;
/**
* 物流单号
*/
private String logisticsNumber;
/**
* 物流公司名称
*/
private String logisticsCompany;
/**
* 收件人
*/
private String contact;
/**
* 收件人手机号码
*/
private String mobile;
/**
* 省
*/
private String province;
/**
* 市
*/
private String city;
/**
* 区
*/
private String town;
/**
* 街道
*/
private String street;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/domain/po/OrderLogistics.java
|
Java
|
unknown
| 1,423
|
package com.hmall.trade.domain.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@ApiModel(description = "订单页面VO")
public class OrderVO {
@ApiModelProperty("订单id")
private Long id;
@ApiModelProperty("总金额，单位为分")
private Integer totalFee;
@ApiModelProperty("支付类型，1、支付宝，2、微信，3、扣减余额")
private Integer paymentType;
@ApiModelProperty("用户id")
private Long userId;
@ApiModelProperty("订单的状态，1、未付款 2、已付款,未发货 3、已发货,未确认 4、确认收货，交易成功 5、交易取消，订单关闭 6、交易结束，已评价")
private Integer status;
@ApiModelProperty("创建时间")
private LocalDateTime createTime;
@ApiModelProperty("支付时间")
private LocalDateTime payTime;
@ApiModelProperty("发货时间")
private LocalDateTime consignTime;
@ApiModelProperty("交易完成时间")
private LocalDateTime endTime;
@ApiModelProperty("交易关闭时间")
private LocalDateTime closeTime;
@ApiModelProperty("评价时间")
private LocalDateTime commentTime;
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/domain/vo/OrderVO.java
|
Java
|
unknown
| 1,253
|
package com.hmall.trade.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.trade.domain.po.OrderDetail;
/**
* <p>
* 订单详情表 Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface OrderDetailMapper extends BaseMapper<OrderDetail> {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/mapper/OrderDetailMapper.java
|
Java
|
unknown
| 307
|
package com.hmall.trade.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.trade.domain.po.OrderLogistics;
/**
* <p>
* Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface OrderLogisticsMapper extends BaseMapper<OrderLogistics> {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/mapper/OrderLogisticsMapper.java
|
Java
|
unknown
| 301
|
package com.hmall.trade.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.trade.domain.po.Order;
/**
* <p>
* Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface OrderMapper extends BaseMapper<Order> {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/mapper/OrderMapper.java
|
Java
|
unknown
| 274
|
package com.hmall.trade.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.trade.domain.po.OrderDetail;
/**
* <p>
* 订单详情表 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IOrderDetailService extends IService<OrderDetail> {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/IOrderDetailService.java
|
Java
|
unknown
| 308
|
package com.hmall.trade.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.trade.domain.po.OrderLogistics;
/**
* <p>
* 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IOrderLogisticsService extends IService<OrderLogistics> {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/IOrderLogisticsService.java
|
Java
|
unknown
| 302
|
package com.hmall.trade.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.trade.domain.dto.OrderFormDTO;
import com.hmall.trade.domain.po.Order;
/**
* <p>
* 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IOrderService extends IService<Order> {
Long createOrder(OrderFormDTO orderFormDTO);
void markOrderPaySuccess(Long orderId);
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/IOrderService.java
|
Java
|
unknown
| 417
|
package com.hmall.trade.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.trade.domain.po.OrderDetail;
import com.hmall.trade.mapper.OrderDetailMapper;
import com.hmall.trade.service.IOrderDetailService;
import org.springframework.stereotype.Service;
/**
* <p>
* 订单详情表 服务实现类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Service
public class OrderDetailServiceImpl extends ServiceImpl<OrderDetailMapper, OrderDetail> implements IOrderDetailService {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/impl/OrderDetailServiceImpl.java
|
Java
|
unknown
| 536
|
package com.hmall.trade.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.trade.domain.po.OrderLogistics;
import com.hmall.trade.mapper.OrderLogisticsMapper;
import com.hmall.trade.service.IOrderLogisticsService;
import org.springframework.stereotype.Service;
/**
* <p>
* 服务实现类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Service
public class OrderLogisticsServiceImpl extends ServiceImpl<OrderLogisticsMapper, OrderLogistics> implements IOrderLogisticsService {
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/impl/OrderLogisticsServiceImpl.java
|
Java
|
unknown
| 542
|
package com.hmall.trade.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.api.client.CartClient;
import com.hmall.api.client.ItemClient;
import com.hmall.api.dto.ItemDTO;
import com.hmall.api.dto.OrderDetailDTO;
import com.hmall.common.exception.BadRequestException;
import com.hmall.common.utils.UserContext;
import com.hmall.trade.domain.dto.OrderFormDTO;
import com.hmall.trade.domain.po.Order;
import com.hmall.trade.domain.po.OrderDetail;
import com.hmall.trade.mapper.OrderMapper;
import com.hmall.trade.service.IOrderDetailService;
import com.hmall.trade.service.IOrderService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
/**
* <p>
* 服务实现类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {
private final ItemClient itemClient;
private final CartClient cartClient;
//private final IItemService itemService;
private final IOrderDetailService detailService;
@Override
@Transactional
public Long createOrder(OrderFormDTO orderFormDTO) {
// 1.订单数据
Order order = new Order();
// 1.1.查询商品
List<OrderDetailDTO> detailDTOS = orderFormDTO.getDetails();
// 1.2.获取商品id和数量的Map
Map<Long, Integer> itemNumMap = detailDTOS.stream()
.collect(Collectors.toMap(OrderDetailDTO::getItemId, OrderDetailDTO::getNum));
Set<Long> itemIds = itemNumMap.keySet();
// 1.3.查询商品
List<ItemDTO> items = itemClient.queryItemsByIds(itemIds);
//List<ItemDTO> items = itemService.queryItemByIds(itemIds);
if (items == null || items.size() < itemIds.size()) {
throw new BadRequestException("商品不存在");
}
// 1.4.基于商品价格、购买数量计算商品总价：totalFee
int total = 0;
for (ItemDTO item : items) {
total += item.getPrice() * itemNumMap.get(item.getId());
}
order.setTotalFee(total);
// 1.5.其它属性
order.setPaymentType(orderFormDTO.getPaymentType());
order.setUserId(UserContext.getUser());
order.setStatus(1);
// 1.6.将Order写入数据库order表中
save(order);
// 2.保存订单详情
List<OrderDetail> details = buildDetails(order.getId(), items, itemNumMap);
detailService.saveBatch(details);
// 3.清理购物车商品
cartClient.deleteCartItemByIds(itemIds);
// 4.扣减库存
try {
itemClient.deductStock(detailDTOS);
} catch (Exception e) {
throw new RuntimeException("库存不足！");
}
return order.getId();
}
@Override
public void markOrderPaySuccess(Long orderId) {
Order order = new Order();
order.setId(orderId);
order.setStatus(2);
order.setPayTime(LocalDateTime.now());
updateById(order);
}
private List<OrderDetail> buildDetails(Long orderId, List<ItemDTO> items, Map<Long, Integer> numMap) {
List<OrderDetail> details = new ArrayList<>(items.size());
for (ItemDTO item : items) {
OrderDetail detail = new OrderDetail();
detail.setName(item.getName());
detail.setSpec(item.getSpec());
detail.setPrice(item.getPrice());
detail.setNum(numMap.get(item.getId()));
detail.setItemId(item.getId());
detail.setImage(item.getImage());
detail.setOrderId(orderId);
details.add(detail);
}
return details;
}
}
|
2201_75631765/hmall
|
trade-service/src/main/java/com/hmall/trade/service/impl/OrderServiceImpl.java
|
Java
|
unknown
| 3,997
|
package com.hmall.user;
import com.hmall.api.config.DefaultFeignConfig;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@MapperScan("com.hmall.user.mapper")
@SpringBootApplication
@EnableFeignClients(defaultConfiguration = DefaultFeignConfig.class)
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/UserApplication.java
|
Java
|
unknown
| 579
|
package com.hmall.user.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.core.io.Resource;
import java.time.Duration;
@Data
@ConfigurationProperties(prefix = "hm.jwt")
public class JwtProperties {
private Resource location;
private String password;
private String alias;
private Duration tokenTTL = Duration.ofMinutes(10);
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/config/JwtProperties.java
|
Java
|
unknown
| 425
|
package com.hmall.user.config;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.rsa.crypto.KeyStoreKeyFactory;
import java.security.KeyPair;
@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {
@Bean
public PasswordEncoder passwordEncoder(){
return new BCryptPasswordEncoder();
}
@Bean
public KeyPair keyPair(JwtProperties properties){
// 获取秘钥工厂
KeyStoreKeyFactory keyStoreKeyFactory =
new KeyStoreKeyFactory(
properties.getLocation(),
properties.getPassword().toCharArray());
//读取钥匙对
return keyStoreKeyFactory.getKeyPair(
properties.getAlias(),
properties.getPassword().toCharArray());
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/config/SecurityConfig.java
|
Java
|
unknown
| 1,145
|
package com.hmall.user.controller;
import com.hmall.common.exception.BadRequestException;
import com.hmall.common.utils.BeanUtils;
import com.hmall.common.utils.CollUtils;
import com.hmall.common.utils.UserContext;
import com.hmall.user.domain.dto.AddressDTO;
import com.hmall.user.domain.po.Address;
import com.hmall.user.service.IAddressService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* <p>
* 前端控制器
* </p>
*
* @author 虎哥
*/
@RestController
@RequestMapping("/addresses")
@RequiredArgsConstructor
@Api(tags = "收货地址管理接口")
public class AddressController {
private final IAddressService addressService;
@ApiOperation("根据id查询地址")
@GetMapping("{addressId}")
public AddressDTO findAddressById(@ApiParam("地址id") @PathVariable("addressId") Long id) {
// 1.根据id查询
Address address = addressService.getById(id);
if (address == null) {
throw new BadRequestException("地址不存在");
}
// 2.判断当前用户
Long userId = UserContext.getUser();
if(!address.getUserId().equals(userId)){
throw new BadRequestException("地址不属于当前登录用户");
}
return BeanUtils.copyBean(address, AddressDTO.class);
}
@ApiOperation("查询当前用户地址列表")
@GetMapping
public List<AddressDTO> findMyAddresses() {
// 1.查询列表
List<Address> list = addressService.query().eq("user_id", UserContext.getUser()).list();
// 2.判空
if (CollUtils.isEmpty(list)) {
return CollUtils.emptyList();
}
// 3.转vo
return BeanUtils.copyList(list, AddressDTO.class);
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/controller/AddressController.java
|
Java
|
unknown
| 2,116
|
package com.hmall.user.controller;
import com.hmall.user.domain.dto.LoginFormDTO;
import com.hmall.user.domain.vo.UserLoginVO;
import com.hmall.user.service.IUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
@Api(tags = "用户相关接口")
@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {
private final IUserService userService;
@ApiOperation("用户登录接口")
@PostMapping("login")
public UserLoginVO login(@RequestBody @Validated LoginFormDTO loginFormDTO){
return userService.login(loginFormDTO);
}
@ApiOperation("扣减余额")
@ApiImplicitParams({
@ApiImplicitParam(name = "pw", value = "支付密码"),
@ApiImplicitParam(name = "amount", value = "支付金额")
})
@PutMapping("/money/deduct")
public void deductMoney(@RequestParam("pw") String pw,@RequestParam("amount") Integer amount){
userService.deductMoney(pw, amount);
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/controller/UserController.java
|
Java
|
unknown
| 1,269
|
package com.hmall.user.domain.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
@Data
@ApiModel(description = "收货地址实体")
public class AddressDTO {
@ApiModelProperty("id")
private Long id;
@ApiModelProperty("省")
private String province;
@ApiModelProperty("市")
private String city;
@ApiModelProperty("县/区")
private String town;
@ApiModelProperty("手机")
private String mobile;
@ApiModelProperty("详细地址")
private String street;
@ApiModelProperty("联系人")
private String contact;
@ApiModelProperty("是否是默认 1默认 0否")
private Integer isDefault;
@ApiModelProperty("备注")
private String notes;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/dto/AddressDTO.java
|
Java
|
unknown
| 774
|
package com.hmall.user.domain.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotNull;
@Data
@ApiModel(description = "登录表单实体")
public class LoginFormDTO {
@ApiModelProperty(value = "用户名", required = true)
@NotNull(message = "用户名不能为空")
private String username;
@NotNull(message = "密码不能为空")
@ApiModelProperty(value = "用户名", required = true)
private String password;
@ApiModelProperty(value = "是否记住我", required = false)
private Boolean rememberMe = false;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/dto/LoginFormDTO.java
|
Java
|
unknown
| 651
|
package com.hmall.user.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
* <p>
*
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("address")
public class Address implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 用户ID
*/
private Long userId;
/**
* 省
*/
private String province;
/**
* 市
*/
private String city;
/**
* 县/区
*/
private String town;
/**
* 手机
*/
private String mobile;
/**
* 详细地址
*/
private String street;
/**
* 联系人
*/
private String contact;
/**
* 是否是默认 1默认 0否
*/
private Integer isDefault;
/**
* 备注
*/
private String notes;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/po/Address.java
|
Java
|
unknown
| 1,198
|
package com.hmall.user.domain.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.hmall.user.enums.UserStatus;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* <p>
* 用户表
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("user")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 用户名
*/
private String username;
/**
* 密码，加密存储
*/
private String password;
/**
* 注册手机号
*/
private String phone;
/**
* 创建时间
*/
private LocalDateTime createTime;
private LocalDateTime updateTime;
/**
* 使用状态（1正常 2冻结）
*/
private UserStatus status;
/**
* 账户余额
*/
private Integer balance;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/po/User.java
|
Java
|
unknown
| 1,197
|
package com.hmall.user.domain.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.time.LocalDateTime;
/**
* <p>
* 支付订单
* </p>
*/
@Data
@ApiModel(description = "支付单vo实体")
public class PayOrderVO {
@ApiModelProperty("id")
private Long id;
@ApiModelProperty("业务订单号")
private Long bizOrderNo;
@ApiModelProperty("支付单号")
private Long payOrderNo;
@ApiModelProperty("支付用户id")
private Long bizUserId;
@ApiModelProperty("支付渠道编码")
private String payChannelCode;
@ApiModelProperty("支付金额，单位分")
private Integer amount;
@ApiModelProperty("付类型，1：h5,2:小程序，3：公众号，4：扫码，5：余额支付")
private Integer payType;
@ApiModelProperty("付状态，0：待提交，1:待支付，2：支付超时或取消，3：支付成功")
private Integer status;
@ApiModelProperty("拓展字段，用于传递不同渠道单独处理的字段")
private String expandJson;
@ApiModelProperty("第三方返回业务码")
private String resultCode;
@ApiModelProperty("第三方返回提示信息")
private String resultMsg;
@ApiModelProperty("支付成功时间")
private LocalDateTime paySuccessTime;
@ApiModelProperty("支付超时时间")
private LocalDateTime payOverTime;
@ApiModelProperty("支付二维码链接")
private String qrCodeUrl;
@ApiModelProperty("创建时间")
private LocalDateTime createTime;
@ApiModelProperty("更新时间")
private LocalDateTime updateTime;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/vo/PayOrderVO.java
|
Java
|
unknown
| 1,658
|
package com.hmall.user.domain.vo;
import lombok.Data;
@Data
public class UserLoginVO {
private String token;
private Long userId;
private String username;
private Integer balance;
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/domain/vo/UserLoginVO.java
|
Java
|
unknown
| 200
|
package com.hmall.user.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import com.hmall.common.exception.BadRequestException;
import lombok.Getter;
@Getter
public enum UserStatus {
FROZEN(0, "禁止使用"),
NORMAL(1, "已激活"),
;
@EnumValue
int value;
String desc;
UserStatus(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
public static UserStatus of(int value) {
if (value == 0) {
return FROZEN;
}
if (value == 1) {
return NORMAL;
}
throw new BadRequestException("账户状态错误");
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/enums/UserStatus.java
|
Java
|
unknown
| 654
|
package com.hmall.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.user.domain.po.Address;
/**
* <p>
* Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface AddressMapper extends BaseMapper<Address> {
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/mapper/AddressMapper.java
|
Java
|
unknown
| 278
|
package com.hmall.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hmall.user.domain.po.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
/**
* <p>
* 用户表 Mapper 接口
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface UserMapper extends BaseMapper<User> {
@Update("update user set balance = balance - ${totalFee} where id = #{userId}")
void updateMoney(@Param("userId") Long userId, @Param("totalFee") Integer totalFee);
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/mapper/UserMapper.java
|
Java
|
unknown
| 539
|
package com.hmall.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.user.domain.po.Address;
/**
* <p>
* 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IAddressService extends IService<Address> {
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/service/IAddressService.java
|
Java
|
unknown
| 279
|
package com.hmall.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.hmall.user.domain.dto.LoginFormDTO;
import com.hmall.user.domain.po.User;
import com.hmall.user.domain.vo.UserLoginVO;
/**
* <p>
* 用户表 服务类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
public interface IUserService extends IService<User> {
UserLoginVO login(LoginFormDTO loginFormDTO);
void deductMoney(String pw, Integer totalFee);
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/service/IUserService.java
|
Java
|
unknown
| 473
|
package com.hmall.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.user.domain.po.Address;
import com.hmall.user.mapper.AddressMapper;
import com.hmall.user.service.IAddressService;
import org.springframework.stereotype.Service;
/**
* <p>
* 服务实现类
* </p>
*
* @author 虎哥
* @since 2023-05-05
*/
@Service
public class AddressServiceImpl extends ServiceImpl<AddressMapper, Address> implements IAddressService {
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/service/impl/AddressServiceImpl.java
|
Java
|
unknown
| 489
|
package com.hmall.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmall.common.exception.BadRequestException;
import com.hmall.common.exception.BizIllegalException;
import com.hmall.common.exception.ForbiddenException;
import com.hmall.common.utils.UserContext;
import com.hmall.user.config.JwtProperties;
import com.hmall.user.domain.dto.LoginFormDTO;
import com.hmall.user.domain.po.User;
import com.hmall.user.domain.vo.UserLoginVO;
import com.hmall.user.enums.UserStatus;
import com.hmall.user.mapper.UserMapper;
import com.hmall.user.service.IUserService;
import com.hmall.user.utils.JwtTool;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
/**
* <p>
* 用户表 服务实现类
* </p>
*
* @author 虎哥
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
private final PasswordEncoder passwordEncoder;
private final JwtTool jwtTool;
private final JwtProperties jwtProperties;
@Override
public UserLoginVO login(LoginFormDTO loginDTO) {
// 1.数据校验
String username = loginDTO.getUsername();
String password = loginDTO.getPassword();
// 2.根据用户名或手机号查询
User user = lambdaQuery().eq(User::getUsername, username).one();
Assert.notNull(user, "用户名错误");
// 3.校验是否禁用
if (user.getStatus() == UserStatus.FROZEN) {
throw new ForbiddenException("用户被冻结");
}
// 4.校验密码
if (!passwordEncoder.matches(password, user.getPassword())) {
throw new BadRequestException("用户名或密码错误");
}
// 5.生成TOKEN
String token = jwtTool.createToken(user.getId(), jwtProperties.getTokenTTL());
// 6.封装VO返回
UserLoginVO vo = new UserLoginVO();
vo.setUserId(user.getId());
vo.setUsername(user.getUsername());
vo.setBalance(user.getBalance());
vo.setToken(token);
return vo;
}
@Override
public void deductMoney(String pw, Integer totalFee) {
log.info("开始扣款");
// 1.校验密码
User user = getById(UserContext.getUser());
if(user == null || !passwordEncoder.matches(pw, user.getPassword())){
// 密码错误
throw new BizIllegalException("用户密码错误");
}
// 2.尝试扣款
try {
baseMapper.updateMoney(UserContext.getUser(), totalFee);
} catch (Exception e) {
throw new RuntimeException("扣款失败，可能是余额不足！", e);
}
log.info("扣款成功");
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/service/impl/UserServiceImpl.java
|
Java
|
unknown
| 2,926
|
package com.hmall.user.utils;
import cn.hutool.core.exceptions.ValidateException;
import cn.hutool.jwt.JWT;
import cn.hutool.jwt.JWTValidator;
import cn.hutool.jwt.signers.JWTSigner;
import cn.hutool.jwt.signers.JWTSignerUtil;
import com.hmall.common.exception.UnauthorizedException;
import org.springframework.stereotype.Component;
import java.security.KeyPair;
import java.time.Duration;
import java.util.Date;
@Component
public class JwtTool {
private final JWTSigner jwtSigner;
public JwtTool(KeyPair keyPair) {
this.jwtSigner = JWTSignerUtil.createSigner("rs256", keyPair);
}
/**
* 创建 access-token
*
* @param
* @return access-token
*/
public String createToken(Long userId, Duration ttl) {
// 1.生成jws
return JWT.create()
.setPayload("user", userId)
.setExpiresAt(new Date(System.currentTimeMillis() + ttl.toMillis()))
.setSigner(jwtSigner)
.sign();
}
/**
* 解析token
*
* @param token token
* @return 解析刷新token得到的用户信息
*/
public Long parseToken(String token) {
// 1.校验token是否为空
if (token == null) {
throw new UnauthorizedException("未登录");
}
// 2.校验并解析jwt
JWT jwt;
try {
jwt = JWT.of(token).setSigner(jwtSigner);
} catch (Exception e) {
throw new UnauthorizedException("无效的token", e);
}
// 2.校验jwt是否有效
if (!jwt.verify()) {
// 验证失败
throw new UnauthorizedException("无效的token");
}
// 3.校验是否过期
try {
JWTValidator.of(jwt).validateDate();
} catch (ValidateException e) {
throw new UnauthorizedException("token已经过期");
}
// 4.数据格式校验
Object userPayload = jwt.getPayload("user");
if (userPayload == null) {
// 数据为空
throw new UnauthorizedException("无效的token");
}
// 5.数据解析
try {
return Long.valueOf(userPayload.toString());
} catch (RuntimeException e) {
// 数据格式有误
throw new UnauthorizedException("无效的token");
}
}
}
|
2201_75631765/hmall
|
user-service/src/main/java/com/hmall/user/utils/JwtTool.java
|
Java
|
unknown
| 2,378
|
package com.example.myapplication;
import android.content.Context;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
assertEquals("com.example.myapplication", appContext.getPackageName());
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/androidTest/java/com/example/myapplication/ExampleInstrumentedTest.java
|
Java
|
unknown
| 764
|
package com.example.myapplication;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import com.example.myapplication.activity.HomeActivity;
import com.example.myapplication.activity.MainActivity2;
import com.example.myapplication.activity.ShapActivity;
import com.example.myapplication.activity.VHomeActivity;
import com.example.myapplication.bases.BaseActivity;
public class MainActivity extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button bt = findViewById(R.id.bt);
Button bt1 = findViewById(R.id.bt1);
Button bt2 = findViewById(R.id.bt2);
Button bt_shape=findViewById(R.id.bt_shape);
Button bt_vhome=findViewById(R.id.bt_vhome);
bt.setOnClickListener(clickListener);
bt1.setOnClickListener(clickListener);
bt2.setOnClickListener(clickListener);
bt_shape.setOnClickListener(clickListener);
bt_vhome.setOnClickListener(clickListener);
}
private View.OnClickListener clickListener=new View.OnClickListener() {
@Override
public void onClick(View view) {
if (view.getId()==R.id.bt){
Intent intent=new Intent();
intent.setClass(MainActivity.this, MainActivity2.class);
startActivity(intent);
}else if (view.getId()==R.id.bt1){
//隐式Intent的
Intent intent=new Intent(Intent.ACTION_SENDTO);
intent.setData(Uri.parse("smsto:10086")); // smsto 表示短信
intent.putExtra("sms_body", "Hello!"); // 短信内容
startActivity(intent);
}else if (view.getId()==R.id.bt2){
//显式Intent
Intent intent=new Intent();
intent.setClass(MainActivity.this, HomeActivity.class);
startActivity(intent);
}else if (view.getId()==R.id.bt_shape){
Intent intent=new Intent();
intent.setClass(MainActivity.this, ShapActivity.class);
startActivity(intent);
}else if (view.getId()==R.id.bt_vhome) {
Intent intent = new Intent();
intent.setClass(MainActivity.this, VHomeActivity.class);
startActivity(intent);
}
}
};
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/MainActivity.java
|
Java
|
unknown
| 2,626
|
package com.example.myapplication.activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
import androidx.annotation.Nullable;
import com.example.myapplication.R;
import com.example.myapplication.bases.BaseActivity;
/**
* @author yuanc
* @Description: (用一句话描述)
* @date 2025/7/30 9:14
*/
public class HomeActivity extends BaseActivity {
private Button btn_life;
private Button btn_savestate;
private Button btn_senddata;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_home);
btn_life = findViewById(R.id.btn_life);
btn_senddata = findViewById(R.id.btn_senddata);
btn_life.setOnClickListener(clickListener);
btn_senddata.setOnClickListener(clickListener);
}
private View.OnClickListener clickListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent();
if (v.getId() == R.id.btn_life) {
Toast.makeText(HomeActivity.this, "请查看日志", Toast.LENGTH_SHORT).show();
}
if (v.getId() == R.id.btn_senddata) {
intent.setClass(HomeActivity.this, ReceiveDataActivity.class);
intent.putExtra("message","我是MainActivity的数据信息");
// 跳转，且要求回传数据
startActivityForResult(intent, 110);
}
}
};
// 回传数据回时，回调的方法
@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (data != null) {
// 取出回传数据
String msg = data.getStringExtra("aaa");
Toast.makeText(this, resultCode + " 回传信息回来了 " + msg, Toast.LENGTH_SHORT).show();
}
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/HomeActivity.java
|
Java
|
unknown
| 2,078
|
package com.example.myapplication.activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.activity.EdgeToEdge;
import com.example.myapplication.R;
import com.example.myapplication.bases.BaseActivity;
public class MainActivity2 extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EdgeToEdge.enable(this);
setContentView(R.layout.activity_main2);
Button bt2=findViewById(R.id.bt2);
bt2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//以下虽然可以回到原来的页面，但是会在栈里不断创造一个Intent，使用方法2解决
// 方法1：
// Intent intent=new Intent();
// intent.setClass(MainActivity2.this, MainActivity.class);
// startActivity(intent);
// 方法2:
MainActivity2.this.finish();
}
});
Button bt_toSaveStateActivity=findViewById(R.id.bt_toSaveStateActivity);
bt_toSaveStateActivity.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent=new Intent();
intent.setClass(MainActivity2.this, SaveStateActivity.class);
startActivity(intent);
}
});
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/MainActivity2.java
|
Java
|
unknown
| 1,541
|
package com.example.myapplication.activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import com.example.myapplication.R;
/**
* 用来接收数据的Activity案例
*
* @author Yuansir
* @version V1.0
* @since 2025/7/30 11:33
*/
public class ReceiveDataActivity extends AppCompatActivity {
private TextView textView;
private Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_receive_date);
// ----------------------------------------------------------
textView = findViewById(R.id.tv_message);
// 取得传入的数据
String msg = getIntent().getStringExtra("message");
// 设置到UI上显示
textView.setText(msg);
// ----------------------------------------------------------
button = findViewById(R.id.btn_back);
// 关闭当前Activity, 回传数据回去
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 设置回传信息
Intent dataIntent = new Intent();
dataIntent.putExtra("aaa", "123123123123123");
setResult(119, dataIntent);
// 结果当前Acitivyt
finish();
}
});
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/ReceiveDataActivity.java
|
Java
|
unknown
| 1,547
|
package com.example.myapplication.activity;
import android.os.Bundle;
import com.example.myapplication.R;
import com.example.myapplication.bases.BaseActivity;
/**
* * SaveStateActivity 是用于保存和恢复Activity状态的示例类。
* * 该类演示了如何在Activity生命周期中保存和恢复状态信息，
* * 以确保在配置更改（如屏幕旋转）时用户数据不会丢失。
*/
public class SaveStateActivity extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_savestate);
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putString("name", "SaveStateActivity");
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/SaveStateActivity.java
|
Java
|
unknown
| 827
|
package com.example.myapplication.activity;
import android.os.Bundle;
import androidx.activity.EdgeToEdge;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;
import com.example.myapplication.R;
public class ShapActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EdgeToEdge.enable(this);
setContentView(R.layout.activity_shap);
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
return insets;
});
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/ShapActivity.java
|
Java
|
unknown
| 891
|
package com.example.myapplication.activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import androidx.activity.EdgeToEdge;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;
import com.example.myapplication.R;
public class VHomeActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EdgeToEdge.enable(this);
setContentView(R.layout.activity_vhome);
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
return insets;
});
Button bt_login=findViewById(R.id.bt);
bt_login.setOnClickListener(clickListener);
}
private View.OnClickListener clickListener =new View.OnClickListener() {
@Override
public void onClick(View view) {
}
};
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/activity/VHomeActivity.java
|
Java
|
unknown
| 1,233
|
package com.example.myapplication.bases;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.example.myapplication.utils.LogUtil;
public class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
LogUtil.d("LOG", "onCreate: " + getClass().getSimpleName());
}
@Override
protected void onStart() {
super.onStart();
LogUtil.d("LOG", "onStart: " + getClass().getSimpleName());
}
@Override
protected void onRestart() {
super.onRestart();
LogUtil.d("LOG", "onRestart: " + getClass().getSimpleName());
}
@Override
protected void onResume() {
super.onResume();
LogUtil.d("LOG", "onResume: " + getClass().getSimpleName());
}
@Override
protected void onPause() {
super.onPause();
LogUtil.d("LOG", "onPause: " + getClass().getSimpleName());
}
@Override
protected void onStop() {
super.onStop();
LogUtil.d("LOG", "onStop: " + getClass().getSimpleName());
}
@Override
protected void onDestroy() {
super.onDestroy();
LogUtil.d("LOG", "onDestroy: " + getClass().getSimpleName());
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/bases/BaseActivity.java
|
Java
|
unknown
| 1,343
|
package com.example.myapplication.utils;
import android.util.Log;
public class LogUtil{
// 用于控制是否打印log
static boolean isDebug = true;
public static void d(String tag, String msg) {
//
if (isDebug)
//打印log
Log.d(tag, msg);
}
}
|
2201_75403000/guigu_learn_Android
|
app/src/main/java/com/example/myapplication/utils/LogUtil.java
|
Java
|
unknown
| 300
|
package com.example.myapplication3;
import android.content.Context;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
assertEquals("com.example.myapplication3", appContext.getPackageName());
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/androidTest/java/com/example/myapplication3/ExampleInstrumentedTest.java
|
Java
|
unknown
| 766
|
package com.example.myapplication3;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.animation.Interpolator;
import android.widget.TextView;
import com.example.myapplication3.base.BaseActivity;
import com.example.myapplication3.home.HomeActivity;
import com.example.myapplication3.splash.SplashActivity;
public class MainActivity extends BaseActivity {
// 练习 主线程更新UI-----------------------------------------------------------
// Handler handler = new Handler(Looper.getMainLooper()) {
// @Override
// public void handleMessage(@NonNull Message msg) {
// if (msg.what == 1) {
// textView.setText(msg.obj + "");
// }
// super.handleMessage(msg);
// }
// };
//
// new Thread(new Runnable() {
// @Override
// public void run() {
// try {
// Thread.sleep(2000);
// }catch (Exception e){
// e.printStackTrace();
// }
// Message msg =Message.obtain();
// msg.what=1;
// msg.obj="我是消息";
// handler.handleMessage(msg);
// }
// }).start();
// 练习 主线程更新UI-----------------------------------------------------------
// 使用示例
// 子线程创建自己的消息循环======================================================
// WorkerThread worker = new WorkerThread();
// worker.start();
// 稍后发送任务
// new Handler(Looper.getMainLooper()).postDelayed(() -> {
// worker.sendTask("第一个任务");
// worker.sendTask("第二个任务");
// }, 1000);
// 子线程创建自己的消息循环======================================================
private TextView textView;
@Override
public int getLayoutMain() {
return R.layout.activity_main;
}
@Override
public void initData() {
}
@Override
public void initView() {
textView=findViewById(R.id.textview);
Animation animation = AnimationUtils.loadAnimation(this,R.anim.animation_text);
textView.startAnimation(animation);
animation.setAnimationListener(new Animation.AnimationListener() {
@Override
public void onAnimationStart(Animation animation) {
}
@Override
public void onAnimationEnd(Animation animation) {
SharedPreferences sp= getSharedPreferences("splash_sp", Context.MODE_PRIVATE);
boolean isFirstlaunch = sp.getBoolean("FirstLaunch",true);
Intent intent = new Intent();
if (isFirstlaunch){
intent.setClass(MainActivity.this, SplashActivity.class);
} else {
intent.setClass(MainActivity.this, HomeActivity.class);
}
startActivity(intent);
finish();
}
@Override
public void onAnimationRepeat(Animation animation) {
}
});
}
@Override
public void initListener() {
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/MainActivity.java
|
Java
|
unknown
| 3,387
|
package com.example.myapplication3.audio;
import android.os.Bundle;
import androidx.activity.EdgeToEdge;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;
import com.example.myapplication3.R;
import com.example.myapplication3.audio.bean.AudioItem;
import com.example.myapplication3.base.BaseActivity;
import java.util.ArrayList;
import java.util.List;
public class AudioActivity extends BaseActivity {
private List<AudioItem> datalist;
private int pageIndex;
private final int size=24;
@Override
public int getLayoutMain() {
return R.layout.activity_audio;
}
@Override
public void initData() {
datalist = new ArrayList<>();
}
@Override
public void initView() {
}
@Override
public void initListener() {
AudioQueryHelper.asynLoadAllAudios(this, pageIndex++, size, new AudioQueryHelper.AudioLoadCallback() {
@Override
public void onAudiosLoaded(List<AudioItem> audios) {
datalist.addAll(audios);
}
});
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/audio/AudioActivity.java
|
Java
|
unknown
| 1,178
|
package com.example.myapplication3.audio;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;
import com.example.myapplication3.audio.bean.AudioItem;
import com.example.myapplication3.utils.LogUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class AudioQueryHelper {
private static final String TAG = "AudioQueryHelper";
private static final ExecutorService executor = Executors.newFixedThreadPool(2);
public static void asynLoadAllAudios(Context context, int pageIndex, int itemCount, AudioLoadCallback callback) {
executor.execute(() -> {
List<AudioItem> audios = new ArrayList<>();
String[] projection = {
MediaStore.Audio.Media._ID,
MediaStore.Audio.Media.TITLE,
MediaStore.Audio.Media.ARTIST,
MediaStore.Audio.Media.ALBUM,
MediaStore.Audio.Media.DATA,
MediaStore.Audio.Media.SIZE,
MediaStore.Audio.Media.DURATION,
MediaStore.Audio.Media.DATE_ADDED,
MediaStore.Audio.Media.DATE_MODIFIED,
MediaStore.Audio.Media.MIME_TYPE
};
String selection = MediaStore.Audio.Media.IS_MUSIC + " != 0";
String sortOrder = MediaStore.Audio.Media.DATE_ADDED + " DESC";
Uri mediaUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
try (Cursor cursor = context.getContentResolver().query(
mediaUri,
projection,
selection,
null,
sortOrder
)) {
if (cursor != null) {
cursor.moveToPosition(pageIndex * itemCount);
while (cursor.moveToNext()) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media._ID));
String title = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.TITLE));
String artist = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.ARTIST));
String album = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.ALBUM));
String path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DATA));
long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.SIZE));
long duration = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DURATION));
long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DATE_ADDED));
long dateModified = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.DATE_MODIFIED));
String mime = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Audio.Media.MIME_TYPE));
Uri uri = ContentUris.withAppendedId(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, id);
AudioItem item = new AudioItem(id, title, artist, album, path, uri,
size, duration, dateAdded, dateModified, mime);
audios.add(item);
if (audios.size() >= itemCount) break;
}
}
} catch (Exception e) {
LogUtils.e(TAG, "获取音频失败", e);
callback.onAudiosLoaded(null);
return;
}
callback.onAudiosLoaded(audios);
});
}
public interface AudioLoadCallback {
void onAudiosLoaded(List<AudioItem> audios);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/audio/AudioQueryHelper.java
|
Java
|
unknown
| 4,003
|
package com.example.myapplication3.audio.adapter;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.example.myapplication3.R;
import com.example.myapplication3.audio.bean.AudioItem;
import com.example.myapplication3.video.bean.VideoItem;
import java.util.List;
public class AudioAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private List<AudioItem> audiolist;
private Context context;
private int mode = LIST;
private static final int LIST=1;
private static final int GRID=2;
public AudioAdapter(List<AudioItem> audiolist, Context context) {
this.audiolist = audiolist;
this.context = context;
}
@Override
public int getItemViewType(int position) {return mode; }
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View itemview;
switch (viewType){
case GRID:
itemview = LayoutInflater.from(context).inflate(R.layout.item_grid_,parent,false);
return new GridViewHolder(itemview);
case LIST:
default:
itemview =LayoutInflater.from(context).inflate(R.layout.item_list_,parent,false);
return new LinearViewHolder(itemview);
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
AudioItem audioItem = audiolist.get(position);
if (holder instanceof GridViewHolder){
}
}
@Override
public int getItemCount() {
return audiolist.size();
}
private class LinearViewHolder extends RecyclerView.ViewHolder{
public LinearViewHolder(@NonNull View itemView) {
super(itemView);
}
}
private class GridViewHolder extends RecyclerView.ViewHolder{
public GridViewHolder(@NonNull View itemView) {
super(itemView);
}
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/audio/adapter/AudioAdapter.java
|
Java
|
unknown
| 2,200
|
package com.example.myapplication3.audio.bean;
import android.net.Uri;
public class AudioItem {
private long id;
private String title;
private String artist;
private String album;
private String path;
private Uri uri;
private long size;
private long duration;
private long dateAdded;
private long dateModified;
private String mimeType;
public AudioItem(long id, String title, String artist, String album, String path, Uri uri,
long size, long duration, long dateAdded, long dateModified, String mimeType) {
this.id = id;
this.title = title;
this.artist = artist;
this.album = album;
this.path = path;
this.uri = uri;
this.size = size;
this.duration = duration;
this.dateAdded = dateAdded;
this.dateModified = dateModified;
this.mimeType = mimeType;
}
// Getters
public long getId() { return id; }
public String getTitle() { return title; }
public String getArtist() { return artist; }
public String getAlbum() { return album; }
public String getPath() { return path; }
public Uri getUri() { return uri; }
public long getSize() { return size; }
public long getDuration() { return duration; }
public long getDateAdded() { return dateAdded; }
public long getDateModified() { return dateModified; }
public String getMimeType() { return mimeType; }
public String getFormattedSize() {
if (size <= 0) return "0 B";
final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"};
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return String.format("%.1f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
}
public String getFormattedDate() {
return android.text.format.DateFormat.format("yyyy-MM-dd HH:mm", dateAdded * 1000).toString();
}
public String getFormattedDuration() {
long seconds = duration / 1000;
long minutes = seconds / 60;
seconds = seconds % 60;
return String.format("%02d:%02d", minutes, seconds);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/audio/bean/AudioItem.java
|
Java
|
unknown
| 2,152
|
package com.example.myapplication3.base;
import android.os.Bundle;
import androidx.activity.EdgeToEdge;
import androidx.annotation.Nullable;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;
import com.example.myapplication3.R;
public abstract class BaseActivity extends LifeCycleActivity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EdgeToEdge.enable(this);
setContentView(getLayoutMain());
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
return insets;
});
initData();
initView();
initListener();
}
public abstract int getLayoutMain();
public abstract void initData() ;
public abstract void initView();
public abstract void initListener() ;
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/base/BaseActivity.java
|
Java
|
unknown
| 1,115
|
package com.example.myapplication3.base;
import android.os.Bundle;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.example.myapplication3.utils.LogUtils;
public class LifeCycleActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onRestart: ");
}
@Override
protected void onStart() {
super.onStart();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onStart: ");
}
@Override
protected void onStop() {
super.onStop();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onStop: ");
}
@Override
protected void onDestroy() {
super.onDestroy();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onDestroy: ");
}
@Override
protected void onPause() {
super.onPause();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onPause: ");
}
@Override
protected void onResume() {
super.onResume();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onResume: ");
}
@Override
protected void onRestart() {
super.onRestart();
LogUtils.i("BaseActivity", getClass().getSimpleName() + " onRestart: ");
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/base/LifeCycleActivity.java
|
Java
|
unknown
| 1,429
|
package com.example.myapplication3.document;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;
import android.webkit.MimeTypeMap;
import com.example.myapplication3.document.bean.DocumentItem;
import com.example.myapplication3.utils.LogUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class DocumentQueryHelper {
private static final String TAG = "DocumentQueryHelper";
private static final ExecutorService executor = Executors.newFixedThreadPool(2);
public static void asynLoadAllDocuments(Context context, int pageIndex, int itemCount, DocumentLoadCallback callback) {
executor.execute(() -> {
List<DocumentItem> documents = new ArrayList<>();
String[] projection = {
MediaStore.Files.FileColumns._ID,
MediaStore.Files.FileColumns.DISPLAY_NAME,
MediaStore.Files.FileColumns.DATA,
MediaStore.Files.FileColumns.SIZE,
MediaStore.Files.FileColumns.DATE_ADDED,
MediaStore.Files.FileColumns.DATE_MODIFIED,
MediaStore.Files.FileColumns.MIME_TYPE
};
// 查询非媒体文件
String selection = MediaStore.Files.FileColumns.MEDIA_TYPE + "="
+ MediaStore.Files.FileColumns.MEDIA_TYPE_NONE;
String sortOrder = MediaStore.Files.FileColumns.DATE_ADDED + " DESC";
Uri mediaUri = MediaStore.Files.getContentUri("external");
try (Cursor cursor = context.getContentResolver().query(
mediaUri,
projection,
selection,
null,
sortOrder
)) {
if (cursor != null) {
cursor.moveToPosition(pageIndex * itemCount);
while (cursor.moveToNext()) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID));
String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DISPLAY_NAME));
String path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATA));
long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.SIZE));
long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATE_ADDED));
long dateModified = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATE_MODIFIED));
String mime = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MIME_TYPE));
// 如果MIME类型为空，尝试从文件名推断
if (mime == null || mime.isEmpty()) {
String extension = MimeTypeMap.getFileExtensionFromUrl(path);
mime = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
}
Uri uri = ContentUris.withAppendedId(MediaStore.Files.getContentUri("external"), id);
String extension = path.substring(path.lastIndexOf(".") + 1).toLowerCase();
DocumentItem item = new DocumentItem(id, name, path, uri,
size, dateAdded, dateModified, mime, extension);
documents.add(item);
if (documents.size() >= itemCount) break;
}
}
} catch (Exception e) {
LogUtils.e(TAG, "获取文档失败", e);
callback.onDocumentsLoaded(null);
return;
}
callback.onDocumentsLoaded(documents);
});
}
public interface DocumentLoadCallback {
void onDocumentsLoaded(List<DocumentItem> documents);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/document/DocumentQueryHelper.java
|
Java
|
unknown
| 4,239
|
package com.example.myapplication3.document.adapter;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.example.myapplication3.R;
import com.example.myapplication3.document.bean.DocumentItem;
import java.util.List;
public class DocumentAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
return null;
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
}
@Override
public int getItemCount() {
return 0;
}
// 实现类似ImageAdapter的结构，针对文档特性调整
// 根据文档类型显示不同的图标
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/document/adapter/DocumentAdapter.java
|
Java
|
unknown
| 1,024
|
package com.example.myapplication3.document.bean;
import android.net.Uri;
public class DocumentItem {
private long id;
private String name;
private String path;
private Uri uri;
private long size;
private long dateAdded;
private long dateModified;
private String mimeType;
private String extension;
public DocumentItem(long id, String name, String path, Uri uri, long size,
long dateAdded, long dateModified, String mimeType, String extension) {
this.id = id;
this.name = name;
this.path = path;
this.uri = uri;
this.size = size;
this.dateAdded = dateAdded;
this.dateModified = dateModified;
this.mimeType = mimeType;
this.extension = extension;
}
// Getters
public long getId() { return id; }
public String getName() { return name; }
public String getPath() { return path; }
public Uri getUri() { return uri; }
public long getSize() { return size; }
public long getDateAdded() { return dateAdded; }
public long getDateModified() { return dateModified; }
public String getMimeType() { return mimeType; }
public String getExtension() { return extension; }
public String getFormattedSize() {
if (size <= 0) return "0 B";
final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"};
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return String.format("%.1f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
}
public String getFormattedDate() {
return android.text.format.DateFormat.format("yyyy-MM-dd HH:mm", dateAdded * 1000).toString();
}
public String getFileType() {
if (mimeType == null) return "Unknown";
if (mimeType.startsWith("application/pdf")) return "PDF";
if (mimeType.startsWith("application/msword")) return "Word";
if (mimeType.startsWith("application/vnd.ms-excel")) return "Excel";
if (mimeType.startsWith("application/vnd.ms-powerpoint")) return "PowerPoint";
if (mimeType.startsWith("text/")) return "Text";
return "Document";
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/document/bean/DocumentItem.java
|
Java
|
unknown
| 2,187
|
package com.example.myapplication3.fragment;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import com.example.myapplication3.R;
/**
* A simple {@link Fragment} subclass.
* Use the {@link SplashPage_1_Fragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class SplashPage_1_Fragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_IMGERES = "imgeRes";
private static final String ARG_COLOR = "color";
private static final String ARG_TEXT = "text";
// TODO: Rename and change types of parameters
private int mImageRes;
private int mColor;
private String mtext;
public SplashPage_1_Fragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param imgeRes Parameter 1.
* @param color Parameter 2.
* @return A new instance of fragment SplashPage_1_Fragment.
*/
// TODO: Rename and change types and number of parameters
public static SplashPage_1_Fragment newInstance(int imgeRes, int color,String text) {
SplashPage_1_Fragment fragment = new SplashPage_1_Fragment();
Bundle args = new Bundle();
args.putInt(ARG_IMGERES, imgeRes);
args.putInt(ARG_COLOR, color);
args.putString(ARG_TEXT, text);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mImageRes = getArguments().getInt(ARG_IMGERES);
mColor = getArguments().getInt(ARG_COLOR);
mtext = getArguments().getString(ARG_TEXT);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view =inflater.inflate(R.layout.fragment_splash_page_1_, container, false);
ImageView imageView = view.findViewById(R.id.imageView);
TextView textView =view.findViewById(R.id.textView);
imageView.setImageResource(mImageRes);
textView.setTextColor(mColor);
textView.setText(mtext);
// Inflate the layout for this fragment
return view ;
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/fragment/SplashPage_1_Fragment.java
|
Java
|
unknown
| 2,650
|
package com.example.myapplication3.home;
import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.cardview.widget.CardView;
import com.example.myapplication3.R;
/**
* 自定义组合布局
*
* @author yuanc
* @Description: (用一句话描述)
* @date 2025/8/9 16:34
*/
public class CardItem extends CardView {
public CardItem(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, android.R.attr.calendarViewStyle);
}
public CardItem(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
initView(context, attrs);
}
private void initView(Context context, AttributeSet attrs) {
// 获取xml属性, 自定义属性在 attrs.xml 中定义
TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.cardItem);
String title = ta.getString(R.styleable.cardItem_myCardItemTitle);
int icon = ta.getResourceId(R.styleable.cardItem_myCardItemIcon, -1);
ta.recycle();
// 将自定义xml布局设定给当前视图,注意 root为this, attachToRoot为true
LayoutInflater.from(context).inflate(R.layout.layout_home_item, this, true);
ImageView iv_icon = findViewById(R.id.iv_icon);
TextView tv_title = findViewById(R.id.iv_title);
// 根据xml属性值，更新数据
tv_title.setText(title);
iv_icon.setImageResource(icon);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/home/CardItem.java
|
Java
|
unknown
| 1,693
|
package com.example.myapplication3.home;
import android.content.Intent;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.cardview.widget.CardView;
import com.example.myapplication3.R;
import com.example.myapplication3.base.BaseActivity;
import com.example.myapplication3.image.ImageActivity;
import com.example.myapplication3.video.VideoActivity;
public class HomeActivity extends BaseActivity {
@Override
public int getLayoutMain() {
return R.layout.activity_home;
}
@Override
public void initData() {
}
private CardView cardView_image;
private CardView cardView_app;
private CardView cardView_audio;
private CardView cardView_vodio;
private CardView cardView_doc;
@Override
public void initView() {
setSupportActionBar(findViewById(R.id.toolbar));
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
cardView_image = findViewById(R.id.card_1_1);
cardView_vodio = findViewById(R.id.card_1_2);
cardView_audio = findViewById(R.id.card_2_1);
cardView_app = findViewById(R.id.card_2_2);
cardView_doc = findViewById(R.id.card_3_1);
}
@Override
public void initListener() {
cardView_image.setOnClickListener(clickListener);
cardView_vodio.setOnClickListener(clickListener);
cardView_audio.setOnClickListener(clickListener);
cardView_app.setOnClickListener(clickListener);
cardView_doc.setOnClickListener(clickListener);
}
private View.OnClickListener clickListener = v -> {
Intent intent = new Intent();
if (v.getId() == R.id.card_1_1) {
intent.setClass(HomeActivity.this, ImageActivity.class);
startActivity(intent);
}
if (v.getId() == R.id.card_1_2) {
intent.setClass(HomeActivity.this, VideoActivity.class);
startActivity(intent);
}
if (v.getId() == R.id.card_2_1) {
Toast.makeText(this, "2-1", Toast.LENGTH_SHORT).show();
}
if (v.getId() == R.id.card_2_2) {
Toast.makeText(this, "2-2", Toast.LENGTH_SHORT).show();
}
if (v.getId() == R.id.card_3_1) {
Toast.makeText(this, "3-1", Toast.LENGTH_SHORT).show();
}
};
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==android.R.id.home){
finish();
}
return super.onOptionsItemSelected(item);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/home/HomeActivity.java
|
Java
|
unknown
| 2,586
|
package com.example.myapplication3.image;
import android.Manifest;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.view.ContextMenu;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.example.myapplication3.R;
import com.example.myapplication3.base.BaseActivity;
import com.example.myapplication3.image.adapter.ImageAdapter;
import com.example.myapplication3.image.bean.ImageItem;
import com.example.myapplication3.video.adapter.VideoAdapter;
import com.scwang.smart.refresh.layout.SmartRefreshLayout;
import java.util.ArrayList;
import java.util.List;
public class ImageActivity extends BaseActivity {
private ImageAdapter adapter;
private SmartRefreshLayout refreshLayout;
private RecyclerView recyclerView;
private List<ImageItem> dataList;
private int pageIndex;
private int size = 24;
@Override
public int getLayoutMain() {
return R.layout.activity_image;
}
@Override
public void initData() {
dataList = new ArrayList<>();
adapter = new ImageAdapter(dataList,this);
}
@Override
public void initView() {
setSupportActionBar(findViewById(R.id.toolbar));
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
refreshLayout = findViewById(R.id.smartrefreshlayout);
recyclerView = findViewById(R.id.recyclerview);
setShowMode(ImageAdapter.MODE_LIST);
registerForContextMenu(recyclerView);
refreshLayout.autoRefresh();
}
@Override
public void initListener() {
refreshLayout.setOnRefreshListener( refreshLayout->{
loadImageData();
});
refreshLayout.setOnLoadMoreListener(refreshLayout -> {
loadImageData();
});
ImageQueryHelper.setImageLoadCallback(images -> {
if (images==null){
Toast.makeText(this,"没有数据",Toast.LENGTH_SHORT).show();
refreshLayout.finishRefresh(false);
refreshLayout.finishLoadMore(false);
return;
}
dataList.addAll(images);
runOnUiThread(() -> {
adapter.notifyItemRangeChanged(pageIndex * size, size);
refreshLayout.finishRefresh(true);
refreshLayout.finishLoadMore(true);
});
});
adapter.setItemOnClickListener((v, position) -> {
ImageItem imageItem = dataList.get(position);
Intent intent = new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.setDataAndType(imageItem.getUri(), imageItem.getMimeType());
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);// 授予临时读取权限
startActivity(intent);
});
adapter.setItemOnLongClickListener((View v, int position) -> {
// 已由上下文菜单处理
});
}
private void loadImageData() {
// 检查权限
if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_MEDIA_IMAGES)
!= PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this,
new String[]{
Manifest.permission.READ_MEDIA_IMAGES
},
1);
return;
}
ImageQueryHelper.asynLoadAllImages(this, pageIndex++, size);
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
loadImageData(); // 权限通过后重试
}
}
private void setShowMode(int mode) {
adapter.setMode(mode);
switch (mode) {
case ImageAdapter.MODE_GRID:
GridLayoutManager gridLayoutManager = new GridLayoutManager(this, 4, GridLayoutManager.VERTICAL, false);
recyclerView.setLayoutManager(gridLayoutManager);
break;
case ImageAdapter.MODE_LIST:
default:
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false);
recyclerView.setLayoutManager(linearLayoutManager);
break;
}
recyclerView.setAdapter(adapter);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_imageview_show,menu);
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==android.R.id.home){
finish();
}
if (item.getItemId()==R.id.menu_list){
setShowMode(VideoAdapter.MODE_LIST);
return true;
}
if (item.getItemId()==R.id.menu_grid){
setShowMode(VideoAdapter.MODE_GRID);
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
getMenuInflater().inflate(R.menu.menu_longcilck,menu);
super.onCreateContextMenu(menu, v, menuInfo);
}
@Override
public boolean onContextItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==R.id.menu_delete){
Toast.makeText(this,"delete",Toast.LENGTH_SHORT).show();
}
if (item.getItemId()==R.id.menu_rename){
Toast.makeText(this,"rename",Toast.LENGTH_SHORT).show();
}
return super.onContextItemSelected(item);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/image/ImageActivity.java
|
Java
|
unknown
| 6,055
|
package com.example.myapplication3.image;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;
import com.example.myapplication3.image.bean.ImageItem;
import com.example.myapplication3.utils.LogUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 图像资源查询业务类
*
* @author yuanc
* @Description: (用一句话描述)
* @date 2025/8/9 19:32
*/
public class ImageQueryHelper {
private static final String TAG = "ImageQueryHelper";
private static final ExecutorService executor = Executors.newFixedThreadPool(2);
/**
* 获取所有图片信息（兼容所有Android版本）
*/
public static void asynLoadAllImages(Context context, int pageIndex, int itemCount) {
executor.execute(() -> {
List<ImageItem> images = new ArrayList<>();
// 定义要查询的列
String[] projection = {
MediaStore.Images.Media._ID,
MediaStore.Images.Media.DISPLAY_NAME,
MediaStore.Images.Media.DATA,
MediaStore.Images.Media.SIZE,
MediaStore.Images.Media.DATE_ADDED,
MediaStore.Images.Media.DATE_MODIFIED,
MediaStore.Images.Media.MIME_TYPE,
MediaStore.Images.Media.WIDTH,
MediaStore.Images.Media.HEIGHT
};
// 只查询相机拍摄的照片
String selection = MediaStore.Images.Media.BUCKET_DISPLAY_NAME + " = 'Camera'";
// 按日期降序排序
String sortOrder = MediaStore.Images.Media.DATE_ADDED + " DESC";
// 媒体文件图像的URI
Uri mediaUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
ContentResolver resolver = context.getContentResolver();
Cursor cursor = resolver.query(
mediaUri,
projection,
null,
null,
sortOrder
);
if (cursor != null) {
try {
// TODO: 定位
cursor.moveToPosition(pageIndex * itemCount);
while (cursor.moveToNext()) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID));
String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME));
String path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA));
long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.SIZE));
long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_ADDED));
long dateModified = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_MODIFIED));
String mime = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.MIME_TYPE));
int width = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.WIDTH));
int height = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.HEIGHT));
Uri uri = ContentUris.withAppendedId(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
id
);
// 构造图像
ImageItem item = new ImageItem(
id,
name,
path,
uri,
size,
dateAdded,
dateModified,
mime,
width,
height
);
images.add(item);
// TODO: 定量
if (images.size() >= itemCount) {
break;
}
}
} catch (Exception e) {
LogUtils.e(TAG, "获取图片失败", e);
loadCallback.onImagesLoaded(null);
} finally {
cursor.close();
}
}
// 结果返回
if (loadCallback != null)
loadCallback.onImagesLoaded(images);
});
}
/**
* 使用系统应用打开图像
*/
private static ImageLoadCallback loadCallback;
public static void setImageLoadCallback(ImageLoadCallback loadCallback) {
ImageQueryHelper.loadCallback = loadCallback;
}
public interface ImageLoadCallback {
void onImagesLoaded(List<ImageItem> images);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/image/ImageQueryHelper.java
|
Java
|
unknown
| 5,229
|
package com.example.myapplication3.image.adapter;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
import com.example.myapplication3.R;
import com.example.myapplication3.image.bean.ImageItem;
import java.io.File;
import java.util.List;
public class ImageAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private List<ImageItem> datas;
private Context context;
public ImageAdapter(List<ImageItem> imageList, Context context) {
datas = imageList;
this.context = context;
}
private int mode = MODE_LIST;
public static final int MODE_LIST = 0;
public static final int MODE_GRID = 1;
public void setMode(int mode) {
this.mode = mode;
}
@Override
public int getItemViewType(int position) {
return mode;
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
final View itemView;
switch (viewType){
case MODE_GRID:
itemView = LayoutInflater.from(context).inflate(R.layout.item_grid_, parent,false);
return new GridViewHolder(itemView);
case MODE_LIST:
default:
itemView = LayoutInflater.from(context).inflate(R.layout.item_list_, parent, false);
return new ListViewHolder(itemView);
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
ImageItem imageItem = datas.get(position);
// 列表模式
if (holder instanceof ListViewHolder) {
ListViewHolder viewHolder = (ListViewHolder) holder;
viewHolder.tv_title.setText(imageItem.getName());
viewHolder.tv_size.setText(imageItem.getFormattedSize());
viewHolder.tv_create_time.setText(imageItem.getFormattedDate());
Glide.with(context)
.load(new File(imageItem.getPath()))
.placeholder(R.drawable.laoding)
.error(R.drawable.ic_image)
.override(160, 160)
.transform(new RoundedCorners(16)) // 圆角半径（单位：px）
.into(viewHolder.iv_icon);
return;
}
// 网格模式
if (holder instanceof GridViewHolder) {
GridViewHolder viewHolder = (GridViewHolder) holder;
Glide.with(context)
.load(new File(imageItem.getPath()))
.placeholder(R.drawable.laoding)
.error(R.drawable.ic_image)
.override(160, 160)
.centerCrop()
.into(viewHolder.iv_icon);
}
}
@Override
public int getItemCount() {
return datas.size();
}
class ListViewHolder extends RecyclerView.ViewHolder {
ImageView iv_icon;
TextView tv_title;
TextView tv_size, tv_create_time;
public ListViewHolder(@NonNull View itemView) {
super(itemView);
iv_icon = itemView.findViewById(R.id.iv_icon);
tv_title = itemView.findViewById(R.id.tv_title);
tv_size = itemView.findViewById(R.id.tv_size);
tv_create_time = itemView.findViewById(R.id.tv_create_time);
itemView.setOnClickListener(v -> {
if (itemOnClickListener != null) {
itemOnClickListener.onClick(v, getAdapterPosition());
}
});
itemView.setOnLongClickListener(v -> {
if (itemOnLongClickListener != null) {
itemOnLongClickListener.onLongClick(v, getAdapterPosition());
}
return false;
});
}
}
class GridViewHolder extends RecyclerView.ViewHolder {
ImageView iv_icon;
public GridViewHolder(@NonNull View itemView) {
super(itemView);
iv_icon = itemView.findViewById(R.id.imageview);
//tv_title = itemView.findViewById(R.id.tv_title);
// item项监听
itemView.setOnClickListener(v -> {
if (itemOnClickListener != null) {
itemOnClickListener.onClick(v, getAdapterPosition());
}
});
itemView.setOnLongClickListener(v -> {
itemView.setClickable(true);
if (itemOnLongClickListener != null) {
itemOnLongClickListener.onLongClick(v, getAdapterPosition());
}
return false;
});
}
}
private ItemOnClickListener itemOnClickListener;
private ItemOnLongClickListener itemOnLongClickListener;
public void setItemOnClickListener(ItemOnClickListener itemOnClickListener){
this.itemOnClickListener=itemOnClickListener;
}
public void setItemOnLongClickListener(ItemOnLongClickListener itemOnLongClickListener){
this.itemOnLongClickListener=itemOnLongClickListener;
}
public interface ItemOnClickListener { void onClick(View v, int position); }
public interface ItemOnLongClickListener { void onLongClick(View v, int position); }
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/image/adapter/ImageAdapter.java
|
Java
|
unknown
| 5,551
|
package com.example.myapplication3.image.bean;
import android.net.Uri;
/**
* 图片项实体类
*
* @author yuanc
* @Description: (用一句话描述)
* @date 2025/8/9 19:36
*/
public class ImageItem {
private long id; // 图像ID
private String name; // 图像名称
private String path; // 图像路径
private Uri uri; // 图像URI
private long size; // 文件大小(字节)
private long dateAdded; // 添加日期(秒)
private long dateModified; // 修改日期(秒)
private String mimeType; // MIME类型
private int width; // 宽度(像素)
private int height; // 高度(像素)
public ImageItem(long id, String name, String path, Uri uri, long size, long dateAdded, long dateModified, String mimeType, int width, int height) {
this.id = id;
this.name = name;
this.path = path;
this.uri = uri;
this.size = size;
this.dateAdded = dateAdded;
this.dateModified = dateModified;
this.mimeType = mimeType;
this.width = width;
this.height = height;
}
public long getId() {
return id;
}
public String getName() {
return name;
}
public String getPath() {
return path;
}
public Uri getUri() {
return uri;
}
public long getSize() {
return size;
}
public long getDateAdded() {
return dateAdded;
}
public long getDateModified() {
return dateModified;
}
public String getMimeType() {
return mimeType;
}
public int getWidth() {
return width;
}
public int getHeight() {
return height;
}
/**
* 获取格式化后的文件大小
*/
public String getFormattedSize() {
if (size <= 0) return "0 B";
final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"};
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return String.format("%.1f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
}
/**
* 获取格式化后的日期
*/
public String getFormattedDate() {
return android.text.format.DateFormat.format("yyyy-MM-dd HH:mm", dateAdded * 1000).toString();
}
/**
* 获取图片分辨率信息
*/
public String getResolutionInfo() {
return width + "×" + height;
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/image/bean/ImageItem.java
|
Java
|
unknown
| 2,476
|
package com.example.myapplication3.splash;
import android.animation.ArgbEvaluator;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.view.View;
import android.widget.TextView;
import androidx.viewpager2.widget.ViewPager2;
import com.example.myapplication3.R;
import com.example.myapplication3.splash.adapter.SplashActivityAdapter;
import com.example.myapplication3.base.BaseActivity;
import com.example.myapplication3.home.HomeActivity;
import me.relex.circleindicator.CircleIndicator3;
public class SplashActivity extends BaseActivity {
private View main;
private TextView textView;
private SplashActivityAdapter adapter;
private ViewPager2 viewPager2;
private CircleIndicator3 indicator; // 图标指示器(第三方控件)
@Override
public int getLayoutMain() {
return R.layout.activity_splash;
}
@Override
public void initData() {
SharedPreferences sp=getSharedPreferences("splash_sp", Context.MODE_PRIVATE);
sp.edit().putBoolean("FirstLaunch", false).commit();
}
@Override
public void initView() {
// 引导页数据
textView = findViewById(R.id.textview);
viewPager2=findViewById(R.id.viewpager2);
main=findViewById(R.id.main);
indicator=findViewById(R.id.circleindicator);
adapter =new SplashActivityAdapter(this);
viewPager2.setAdapter(adapter);
// 注意：先设置ViewPager，后设置指示器
indicator.createIndicators(3, 0);
indicator.setViewPager(viewPager2);
}
@Override
public void initListener() {
textView.setOnClickListener(v -> {
Intent intent = new Intent(SplashActivity.this, HomeActivity.class);
startActivity(intent);
finish();
});
viewPager2.registerOnPageChangeCallback(new ViewPager2.OnPageChangeCallback() {
ArgbEvaluator argbEvaluator = new ArgbEvaluator();
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
super.onPageScrolled(position, positionOffset, positionOffsetPixels);
if (position == 0) {
Object sColor = getResources().getColor(R.color.page3);
Object eColor = getResources().getColor(R.color.page1);
int bg = (int) argbEvaluator.evaluate(positionOffset, sColor, eColor);
main.setBackgroundColor(bg);
}
if (position == 1) {
Object sColor = getResources().getColor(R.color.page1);
Object eColor = getResources().getColor(R.color.page3);
int bg1 = (int) argbEvaluator.evaluate(positionOffset, sColor, eColor);
main.setBackgroundColor(bg1);
}
}
@Override
public void onPageSelected(int position) {
super.onPageSelected(position);
}
});
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/splash/SplashActivity.java
|
Java
|
unknown
| 3,098
|
package com.example.myapplication3.splash.adapter;
import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.viewpager2.adapter.FragmentStateAdapter;
import com.example.myapplication3.R;
import com.example.myapplication3.fragment.SplashPage_1_Fragment;
public class SplashActivityAdapter extends FragmentStateAdapter {
public SplashActivityAdapter(@NonNull FragmentActivity fragmentActivity) {
super(fragmentActivity);
}
@NonNull
@Override
public Fragment createFragment(int position) {
if (position==0){
return SplashPage_1_Fragment.newInstance(R.drawable.ic_home_image,0xff008800,"掌控艺术像素的每一帧图片");
}if (position==1){
return SplashPage_1_Fragment.newInstance(R.drawable.ic_home_audio,0xff000088,"无损沉静全景环绕音乐");
}
return SplashPage_1_Fragment.newInstance(R.drawable.ic_home_doc,0xff008800,"至尊圣旨亲发文件");
}
@Override
public int getItemCount() {
return 3;
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/splash/adapter/SplashActivityAdapter.java
|
Java
|
unknown
| 1,107
|
package com.example.myapplication3.thread;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import androidx.annotation.NonNull;
public class WorkerThread extends Thread{
private Handler workerHandler;
public WorkerThread() {
}
@Override
public void run() {
Looper.prepare();
workerHandler =new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
if (msg.what==1){
System.out.println("处理任务: " + msg.obj);
}
super.handleMessage(msg);
}
};
Looper.loop();
super.run();
}
public void sendTask(String task) {
if (workerHandler != null) {
Message msg = Message.obtain();
msg.what = 1;
msg.obj = task;
workerHandler.sendMessage(msg);
}
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/thread/WorkerThread.java
|
Java
|
unknown
| 934
|
package com.example.myapplication3.utils;
import android.util.Log;
/**
* @author yuanc
* @Description: (用一句话描述)
* @date 2025/7/30 9:57
*/
public class LogUtils {
public static boolean idDebug = true;
public static final String TAG = "TAG";
public static void d(String TAG, String msg) {
if (idDebug) {
Log.d(TAG, msg);
}
}
public static void d(String msg) {
if (idDebug) {
Log.d(TAG, msg);
}
}
public static void e(String msg, Exception e) {
if (idDebug) {
Log.e(TAG, msg, e);
}
}
public static void e(String TAG, String msg, Exception e) {
if (idDebug) {
Log.e(TAG, msg, e);
}
}
public static void i(String msg) {
if (idDebug) {
Log.i(TAG, msg);
}
}
public static void i(String TAG, String msg) {
if (idDebug) {
Log.i(TAG, msg);
}
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/utils/LogUtils.java
|
Java
|
unknown
| 985
|
package com.example.myapplication3.video;
import android.Manifest;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.util.Log;
import android.view.ContextMenu;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;
import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.example.myapplication3.R;
import com.example.myapplication3.base.BaseActivity;
import com.example.myapplication3.video.adapter.VideoAdapter;
import com.example.myapplication3.video.bean.VideoItem;
import com.scwang.smart.refresh.layout.SmartRefreshLayout;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class VideoActivity extends BaseActivity {
private List<VideoItem> datalist;
private VideoAdapter adapter;
private SmartRefreshLayout refreshLayout;
private RecyclerView recyclerView;
private int pageIndex;
private int size = 24;
private Uri selectedUri;
@Override
public int getLayoutMain() {
return R.layout.activity_video;
}
@Override
public void initData() {
datalist = new ArrayList<>();
}
@Override
public void initView() {
setSupportActionBar(findViewById(R.id.toolbar));
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
refreshLayout=findViewById(R.id.smartrefreshlayout);
adapter = new VideoAdapter(datalist, this);
recyclerView = findViewById(R.id.recyclerview);
setShowMode(VideoAdapter.MODE_LIST);
refreshLayout.autoRefresh(200);
recyclerView.setAdapter(adapter);
registerForContextMenu(recyclerView);
}
@Override
public void initListener() {
refreshLayout.setOnRefreshListener( refreshLayout->{
loadVideoData();
});
refreshLayout.setOnLoadMoreListener(refreshLayout -> {
loadVideoData();
});
adapter.setItemOnclickListener(new VideoAdapter.ItemOnclickListener() {
@Override
public void onClick(View view, int position) {
VideoItem videoItem = datalist.get(position);
Intent intent = new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.setDataAndType(videoItem.getUri(), videoItem.getMimeType());
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);// 授予临时读取权限
startActivity(intent);
}
});
adapter.setItemOnLongclickListener(new VideoAdapter.ItemOnLongclickListener() {
@Override
public void onLongClick(View view, int position) {
VideoItem videoItem = datalist.get(position);
selectedUri = videoItem.getUri();
}
});
}
private void loadVideoData() {
// 检查权限
if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_MEDIA_VIDEO)
!= PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this,
new String[]{
Manifest.permission.READ_MEDIA_VIDEO
},
1);
return;
} else {
VideoQueryHelper.asynLoadAllVideos(this, pageIndex++, size, new VideoQueryHelper.VideoLoadCallback() {
@Override
public void onVideosLoaded(List<VideoItem> videos) {
if (videos==null){
Toast.makeText(VideoActivity.this,"没有数据",Toast.LENGTH_SHORT).show();
refreshLayout.finishRefresh(false);
refreshLayout.finishLoadMore(false);
return;
}
datalist.addAll(videos);
runOnUiThread(() -> {
adapter.notifyItemRangeChanged(pageIndex * size, size);
refreshLayout.finishRefresh(true);
refreshLayout.finishLoadMore(true);
});
}
});
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
loadVideoData(); // 权限通过后重试
}
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.menu_imageview_show, menu);
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId() == android.R.id.home) {
finish();
}if (item.getItemId() == R.id.menu_list) {
setShowMode(VideoAdapter.MODE_LIST);
}if (item.getItemId()==R.id.menu_grid){
setShowMode(VideoAdapter.MODE_GRID);
}
return super.onOptionsItemSelected(item);
}
@Override
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
getMenuInflater().inflate(R.menu.menu_longcilck,menu);
}
@Override
public boolean onContextItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==R.id.menu_delete){
// 假设你有要删除的照片的 Uri
Uri uri = selectedUri; // 这里应该是你要删除的照片的 Uri
try {
// 删除媒体库中的记录
int deletedRows = getContentResolver().delete(
uri,
null,
null
);
if (deletedRows > 0) {
// 删除成功
Toast.makeText(this, "照片已删除", Toast.LENGTH_SHORT).show();
// 可选：同时删除实际文件（某些设备可能需要）
String filePath = getPathFromUri(uri); // 需要实现这个方法
if (filePath != null) {
File file = new File(filePath);
if (file.delete()) {
Log.d("Delete", "文件已删除");
}
}
} else {
Toast.makeText(this, "删除失败", Toast.LENGTH_SHORT).show();
}
}
catch (Exception e) {
e.printStackTrace();
Toast.makeText(this, "删除出错: " + e.getMessage(), Toast.LENGTH_SHORT).show();
}
}
return super.onContextItemSelected(item);
}
public String getPathFromUri(Uri uri) {
String path = null;
String[] projection = {MediaStore.Video.Media.DATA};
Cursor cursor = getContentResolver().query(uri, projection, null, null, null);
if (cursor != null && cursor.moveToFirst()) {
int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA);
path = cursor.getString(columnIndex);
cursor.close();
}
return path;
}
private void setShowMode(int mode) {
adapter.setMode(mode);
switch (mode) {
case VideoAdapter.MODE_GRID:
GridLayoutManager gridLayoutManager = new GridLayoutManager(this, 4, GridLayoutManager.VERTICAL, false);
recyclerView.setLayoutManager(gridLayoutManager);
break;
case VideoAdapter.MODE_LIST:
default:
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false);
recyclerView.setLayoutManager(linearLayoutManager);
break;
}
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/video/VideoActivity.java
|
Java
|
unknown
| 8,545
|
package com.example.myapplication3.video;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.provider.MediaStore;
import com.example.myapplication3.video.bean.VideoItem;
import com.example.myapplication3.utils.LogUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class VideoQueryHelper {
private static final String TAG = "VideoQueryHelper";
private static final ExecutorService executor = Executors.newFixedThreadPool(2);
public static void asynLoadAllVideos(Context context, int pageIndex, int itemCount, VideoLoadCallback callback) {
executor.execute(() -> {
List<VideoItem> videos = new ArrayList<>();
String[] projection = {
MediaStore.Video.Media._ID,
MediaStore.Video.Media.DISPLAY_NAME,
MediaStore.Video.Media.DATA,
MediaStore.Video.Media.SIZE,
MediaStore.Video.Media.DURATION,
MediaStore.Video.Media.DATE_ADDED,
MediaStore.Video.Media.DATE_MODIFIED,
MediaStore.Video.Media.MIME_TYPE,
MediaStore.Video.Media.WIDTH,
MediaStore.Video.Media.HEIGHT
};
String sortOrder = MediaStore.Video.Media.DATE_ADDED + " DESC";
Uri mediaUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
try (Cursor cursor = context.getContentResolver().query(
mediaUri,
projection,
null,
null,
sortOrder
)) {
if (cursor != null) {
cursor.moveToPosition(pageIndex * itemCount);
while (cursor.moveToNext()) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID));
String name = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME));
String path = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA));
long size = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE));
long duration = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION));
long dateAdded = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_ADDED));
long dateModified = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATE_MODIFIED));
String mime = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.MIME_TYPE));
int width = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.WIDTH));
int height = cursor.getInt(cursor.getColumnIndexOrThrow(MediaStore.Video.Media.HEIGHT));
Uri uri = ContentUris.withAppendedId(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);
VideoItem item = new VideoItem(id, name, path, uri, size, duration,
dateAdded, dateModified, mime, width, height);
videos.add(item);
if (videos.size() >= itemCount) break;
}
}
} catch (Exception e) {
LogUtils.e(TAG, "获取视频失败", e);
callback.onVideosLoaded(null);
return;
}
callback.onVideosLoaded(videos);
});
}
public interface VideoLoadCallback {
void onVideosLoaded(List<VideoItem> videos);
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/video/VideoQueryHelper.java
|
Java
|
unknown
| 3,924
|
package com.example.myapplication3.video.adapter;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
import com.example.myapplication3.R;
import com.example.myapplication3.image.adapter.ImageAdapter;
import com.example.myapplication3.video.bean.VideoItem;
import java.io.File;
import java.util.List;
public class VideoAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private List<VideoItem> videolists;
private Context context;
private int mode = MODE_LIST;
public static final int MODE_LIST = 0;
public static final int MODE_GRID = 1;
private ItemOnclickListener itemOnclickListener;
private ItemOnLongclickListener itemOnLongclickListener;
public VideoAdapter(List<VideoItem> videolists, Context context) {
this.videolists = videolists;
this.context = context;
}
public void setMode(int mode) {
this.mode = mode;
}
@Override
public int getItemViewType(int position) {return mode;}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
final View itemView;
switch (viewType){
case MODE_GRID:
itemView = LayoutInflater.from(context).inflate(R.layout.item_grid_, parent,false);
return new VideoAdapter.GridViewHolder(itemView);
case MODE_LIST:
default:
itemView = LayoutInflater.from(context).inflate(R.layout.item_list_, parent, false);
return new VideoAdapter.ListViewHolder(itemView);
}
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
VideoItem videoItem = videolists.get(position);
// 列表模式
if (holder instanceof VideoAdapter.ListViewHolder) {
VideoAdapter.ListViewHolder viewHolder = (VideoAdapter.ListViewHolder) holder;
viewHolder.tv_title.setText(videoItem.getName());
viewHolder.tv_size.setText(videoItem.getFormattedSize());
viewHolder.tv_create_time.setText(videoItem.getFormattedDate());
Glide.with(context)
.load(new File(videoItem.getPath()))
.placeholder(R.drawable.laoding)
.error(R.drawable.ic_image)
.override(160, 160)
.transform(new RoundedCorners(16)) // 圆角半径（单位：px）
.into(viewHolder.iv_icon);
return;
}
// 网格模式
if (holder instanceof VideoAdapter.GridViewHolder) {
VideoAdapter.GridViewHolder viewHolder = (VideoAdapter.GridViewHolder) holder;
Glide.with(context)
.load(new File(videoItem.getPath()))
.placeholder(R.drawable.laoding)
.error(R.drawable.ic_image)
.override(160, 160)
.centerCrop()
.into(viewHolder.iv_icon);
}
}
@Override
public int getItemCount() {return videolists.size();}
public class ListViewHolder extends RecyclerView.ViewHolder{
ImageView iv_icon;
TextView tv_title;
TextView tv_size, tv_create_time;
public ListViewHolder(@NonNull View itemView) {
super(itemView);
iv_icon = itemView.findViewById(R.id.iv_icon);
tv_title = itemView.findViewById(R.id.tv_title);
tv_size = itemView.findViewById(R.id.tv_size);
tv_create_time = itemView.findViewById(R.id.tv_create_time);
itemView.setOnClickListener(v -> {
if (itemOnclickListener!=null){
itemOnclickListener.onClick(v,getAdapterPosition());
}
});
itemView.setOnLongClickListener(v -> {
if (itemOnLongclickListener!=null){
itemOnLongclickListener.onLongClick(v,getAdapterPosition());
}
return false;
});
}
}
public class GridViewHolder extends RecyclerView.ViewHolder{
ImageView iv_icon;
public GridViewHolder(@NonNull View itemView) {
super(itemView);
iv_icon = itemView.findViewById(R.id.imageview);
itemView.setOnClickListener(v -> {
if (itemOnclickListener!=null){
itemOnclickListener.onClick(v,getAdapterPosition());
}
});
itemView.setOnLongClickListener(v -> {
if (itemOnLongclickListener!=null){
itemOnLongclickListener.onLongClick(v,getAdapterPosition());
}
return false;
});
}
}
public void setItemOnclickListener(ItemOnclickListener itemOnclickListener){this.itemOnclickListener=itemOnclickListener;}
public void setItemOnLongclickListener(ItemOnLongclickListener itemOnLongclickListener){this.itemOnLongclickListener=itemOnLongclickListener;}
public interface ItemOnclickListener{ void onClick(View view,int position);}
public interface ItemOnLongclickListener{ void onLongClick(View view,int position);}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/video/adapter/VideoAdapter.java
|
Java
|
unknown
| 5,541
|
package com.example.myapplication3.video.bean;
import android.net.Uri;
public class VideoItem {
private long id;
private String name;
private String path;
private Uri uri;
private long size;
private long duration;
private long dateAdded;
private long dateModified;
private String mimeType;
private int width;
private int height;
public VideoItem(long id, String name, String path, Uri uri, long size, long duration,
long dateAdded, long dateModified, String mimeType, int width, int height) {
this.id = id;
this.name = name;
this.path = path;
this.uri = uri;
this.size = size;
this.duration = duration;
this.dateAdded = dateAdded;
this.dateModified = dateModified;
this.mimeType = mimeType;
this.width = width;
this.height = height;
}
// Getters
public long getId() { return id; }
public String getName() { return name; }
public String getPath() { return path; }
public Uri getUri() { return uri; }
public long getSize() { return size; }
public long getDuration() { return duration; }
public long getDateAdded() { return dateAdded; }
public long getDateModified() { return dateModified; }
public String getMimeType() { return mimeType; }
public int getWidth() { return width; }
public int getHeight() { return height; }
public String getFormattedSize() {
if (size <= 0) return "0 B";
final String[] units = new String[]{"B", "KB", "MB", "GB", "TB"};
int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
return String.format("%.1f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
}
public String getFormattedDate() {
return android.text.format.DateFormat.format("yyyy-MM-dd HH:mm", dateAdded * 1000).toString();
}
public String getFormattedDuration() {
long seconds = duration / 1000;
long minutes = seconds / 60;
seconds = seconds % 60;
return String.format("%02d:%02d", minutes, seconds);
}
public String getResolutionInfo() {
return width + "×" + height;
}
}
|
2201_75403000/MediaWatch_APP
|
app/src/main/java/com/example/myapplication3/video/bean/VideoItem.java
|
Java
|
unknown
| 2,213
|
package com.example.demo2_viewpage;
import android.content.Context;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
assertEquals("com.example.demo2_viewpage.test", appContext.getPackageName());
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/androidTest/java/com/example/demo2_viewpage/ExampleInstrumentedTest.java
|
Java
|
unknown
| 771
|
package com.example.demo2_viewpage;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link AFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class AFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public AFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment AFragment.
*/
// TODO: Rename and change types and number of parameters
public static AFragment newInstance(String param1, String param2) {
AFragment fragment = new AFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_a, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/AFragment.java
|
Java
|
unknown
| 2,005
|
package com.example.demo2_viewpage;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link BFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class BFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public BFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment BFragment.
*/
// TODO: Rename and change types and number of parameters
public static BFragment newInstance(String param1, String param2) {
BFragment fragment = new BFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_b, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/BFragment.java
|
Java
|
unknown
| 2,005
|
package com.example.demo2_viewpage;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link CFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class CFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public CFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment CFragment.
*/
// TODO: Rename and change types and number of parameters
public static CFragment newInstance(String param1, String param2) {
CFragment fragment = new CFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_c, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/CFragment.java
|
Java
|
unknown
| 2,005
|
package com.example.demo2_viewpage;
import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
* A simple {@link Fragment} subclass.
* Use the {@link DFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class DFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public DFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment DFragment.
*/
// TODO: Rename and change types and number of parameters
public static DFragment newInstance(String param1, String param2) {
DFragment fragment = new DFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_d, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/DFragment.java
|
Java
|
unknown
| 2,005
|
package com.example.demo2_viewpage;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import androidx.viewpager.widget.PagerAdapter;
import java.util.List;
public class MyAdapter extends FragmentPagerAdapter {
private List<Fragment> list;
public MyAdapter(@NonNull FragmentManager fm,List<Fragment> list) {
super(fm);
this.list=list;
}
@NonNull
@Override
public Fragment getItem(int position) {
return list.get(position);
}
@Override
public int getCount() {
return list.size();
}
@Nullable
@Override
public CharSequence getPageTitle(int position) {
return "测试"+position;
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/MyAdapter.java
|
Java
|
unknown
| 839
|
package com.example.demo2_viewpage;
import android.os.Bundle;
import android.view.MenuItem;
import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.fragment.app.Fragment;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;
import java.util.ArrayList;
import java.util.List;
public class ViewPageActivity extends AppCompatActivity {
private List<Fragment> lists;
private ViewPager viewPager;
private MyAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_view_page);
Toolbar toolbar =findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
viewPager=findViewById(R.id.viewpager);
lists = new ArrayList<>();
lists.add(new AFragment());
lists.add(new BFragment());
lists.add(new CFragment());
lists.add(new DFragment());
adapter=new MyAdapter(getSupportFragmentManager(),lists);
viewPager.setAdapter(adapter);
TabLayout tabLayout =findViewById(R.id.tablayout);
tabLayout.setupWithViewPager(viewPager,true);
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==android.R.id.home){
finish();
}
return super.onOptionsItemSelected(item);
}
}
|
2201_75403000/MediaWatch_APP
|
demo2_viewpage/src/main/java/com/example/demo2_viewpage/ViewPageActivity.java
|
Java
|
unknown
| 1,604
|
package com.example.demo3_viewpager2;
import android.content.Context;
import androidx.test.platform.app.InstrumentationRegistry;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
assertEquals("com.example.demo3_viewpager2.test", appContext.getPackageName());
}
}
|
2201_75403000/MediaWatch_APP
|
demo3_viewpager2/src/androidTest/java/com/example/demo3_viewpager2/ExampleInstrumentedTest.java
|
Java
|
unknown
| 775
|
package com.example.demo3_viewpager2;
import android.os.Bundle;
import android.view.MenuItem;
import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;
import androidx.viewpager2.widget.ViewPager2;
import com.google.android.material.tabs.TabLayout;
import com.google.android.material.tabs.TabLayoutMediator;
public class ViewPager2Activity extends AppCompatActivity {
private ViewPager2 viewPager2;
private ViewPager2Adapter adapter;
private TabLayout tabLayout;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_view_pager2);
Toolbar toolbar =findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
viewPager2=findViewById(R.id.viewpager2);
tabLayout=findViewById(R.id.tablayout);
adapter=new ViewPager2Adapter(this);
viewPager2.setAdapter(adapter);
TabLayoutMediator tabLayoutMediator= new TabLayoutMediator(
tabLayout,
viewPager2,
new TabLayoutMediator.TabConfigurationStrategy() {
@Override
public void onConfigureTab(@NonNull TabLayout.Tab tab, int position) {
tab.setText("测试"+position);
}
}
);
tabLayoutMediator.attach();
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
if (item.getItemId()==android.R.id.home){
finish();
}
return super.onOptionsItemSelected(item);
}
}
|
2201_75403000/MediaWatch_APP
|
demo3_viewpager2/src/main/java/com/example/demo3_viewpager2/ViewPager2Activity.java
|
Java
|
unknown
| 1,911
|
package com.example.demo3_viewpager2;
import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.viewpager2.adapter.FragmentStateAdapter;
import com.example.demo3_viewpager2.fragment.AFragment;
import com.example.demo3_viewpager2.fragment.BFragment;
import com.example.demo3_viewpager2.fragment.CFragment;
import com.example.demo3_viewpager2.fragment.DFragment;
public class ViewPager2Adapter extends FragmentStateAdapter {
public ViewPager2Adapter(@NonNull FragmentActivity fragmentActivity) {
super(fragmentActivity);
}
@NonNull
@Override
public Fragment createFragment(int position) {
switch (position){
case 0:
return new AFragment();
case 1:
return new BFragment();
case 2:
return new CFragment();
case 3:
return new DFragment();
}
return null;
}
@Override
public int getItemCount() {
return 4;
}
}
|
2201_75403000/MediaWatch_APP
|
demo3_viewpager2/src/main/java/com/example/demo3_viewpager2/ViewPager2Adapter.java
|
Java
|
unknown
| 1,076
|
package com.example.demo3_viewpager2.fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.fragment.app.Fragment;
import com.example.demo3_viewpager2.R;
/**
* A simple {@link Fragment} subclass.
* Use the {@link AFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class AFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public AFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment AFragment.
*/
// TODO: Rename and change types and number of parameters
public static AFragment newInstance(String param1, String param2) {
AFragment fragment = new AFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_a, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo3_viewpager2/src/main/java/com/example/demo3_viewpager2/fragment/AFragment.java
|
Java
|
unknown
| 2,055
|
package com.example.demo3_viewpager2.fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.fragment.app.Fragment;
import com.example.demo3_viewpager2.R;
/**
* A simple {@link Fragment} subclass.
* Use the {@link BFragment#newInstance} factory method to
* create an instance of this fragment.
*/
public class BFragment extends Fragment {
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private static final String ARG_PARAM1 = "param1";
private static final String ARG_PARAM2 = "param2";
// TODO: Rename and change types of parameters
private String mParam1;
private String mParam2;
public BFragment() {
// Required empty public constructor
}
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment BFragment.
*/
// TODO: Rename and change types and number of parameters
public static BFragment newInstance(String param1, String param2) {
BFragment fragment = new BFragment();
Bundle args = new Bundle();
args.putString(ARG_PARAM1, param1);
args.putString(ARG_PARAM2, param2);
fragment.setArguments(args);
return fragment;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (getArguments() != null) {
mParam1 = getArguments().getString(ARG_PARAM1);
mParam2 = getArguments().getString(ARG_PARAM2);
}
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_b, container, false);
}
}
|
2201_75403000/MediaWatch_APP
|
demo3_viewpager2/src/main/java/com/example/demo3_viewpager2/fragment/BFragment.java
|
Java
|
unknown
| 2,053
|