yangyakun921/MoGoEagleEye
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/dev_robobus-d_241202_6.8.4' into dev_robobus-d_241202_6.8.4

Browse Source
This commit is contained in:
xyz
2024-12-11 16:27:51 +08:00
parent f34ad665a6 bc48edacd5
commit da85bc2215
845 changed files with 352 additions and 19668 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
OCH/common/common/src/main/java/com/mogo/och/common/module/biz/order/TaxiOrderStatusEnum.kt → OCH/common/data/src/main/java/com/mogo/och/data/taxi/TaxiOrderStatusEnum.kt
View File

@@ -1,4 +1,4 @@
package com.mogo.och.common.module.biz.order
package com.mogo.och.data.taxi
/**
* Created on 2021/12/7

1
OCH/taxi/driver/.gitignore vendored
View File

@@ -1 +0,0 @@
/build

74
OCH/taxi/driver/build.gradle
View File

@@ -1,74 +0,0 @@
apply plugin: 'com.android.library'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'
android {
compileSdkVersion rootProject.ext.android.compileSdkVersion
// buildToolsVersion rootProject.ext.android.buildToolsVersion
defaultConfig {
minSdkVersion rootProject.ext.android.minSdkVersion
targetSdkVersion rootProject.ext.android.targetSdkVersion
versionCode Integer.valueOf(VERSION_CODE)
versionName getValueFromRootProperties("${project.name.replace("-", "_").toUpperCase()}_VERSION")
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
consumerProguardFiles "consumer-rules.pro"
kapt {
useBuildCache = false
arguments {
arg("AROUTER_MODULE_NAME", "taxi"+project.getName())
}
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
lintOptions {
abortOnError false
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
debug {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
sourceSets {
main {
res.srcDirs = [
'src/main/res',
'src/main/res/ani',
]
}
}
}
dependencies {
implementation fileTree(dir: "libs", include: ["*.jar"])
implementation rootProject.ext.dependencies.kotlinstdlib
implementation rootProject.ext.dependencies.androidxappcompat
implementation rootProject.ext.dependencies.arouter
implementation rootProject.ext.dependencies.androidxrecyclerview
implementation rootProject.ext.dependencies.material
kapt rootProject.ext.dependencies.aroutercompiler
implementation rootProject.ext.dependencies.rxandroid
implementation rootProject.ext.dependencies.androidxconstraintlayout
implementation rootProject.ext.dependencies.amapnavi3dmap
implementation project(":OCH:common:common")
compileOnly project(":libraries:mogo-map")
}
apply from: new File(rootProject.rootDir, "gradle/upload.gradle").toString()

0
OCH/taxi/driver/consumer-rules.pro
View File

3
OCH/taxi/driver/gradle.properties
View File

@@ -1,3 +0,0 @@
GROUP=com.mogo.och
POM_ARTIFACT_ID=och-taxi
VERSION_CODE=1

21
OCH/taxi/driver/proguard-rules.pro vendored
View File

@@ -1,21 +0,0 @@
# Add project specific ProGuard rules here.
# You can control the set of applied configuration files using the
# proguardFiles setting in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
# Uncomment this to preserve the line number information for
# debugging stack traces.
#-keepattributes SourceFile,LineNumberTable
# If you keep the line number information, uncomment this to
# hide the original source file name.
#-renamesourcefileattribute SourceFile

2
OCH/taxi/driver/src/main/AndroidManifest.xml
View File

@@ -1,2 +0,0 @@
<manifest package="com.mogo.och.taxi">
</manifest>

BIN
OCH/taxi/driver/src/main/assets/map_style.data
View File

Binary file not shown.

BIN
OCH/taxi/driver/src/main/assets/map_style_extra.data
View File

Binary file not shown.

46
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/TaxiDriverProvider.kt
View File

@@ -1,46 +0,0 @@
package com.mogo.och.taxi
import android.content.Context
import androidx.fragment.app.Fragment
import com.alibaba.android.arouter.facade.annotation.Route
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
import com.mogo.och.common.module.constant.OchCommonConst
import com.mogo.och.common.module.biz.provider.CommonService
import com.mogo.och.common.module.biz.provider.CommonServiceImpl
import com.mogo.och.common.module.manager.autopilot.autopilot.OchAutopilotAnalytics
import com.mogo.och.taxi.ui.TaxiFragment
import com.mogo.och.taxi.utils.TaxiAnalyticsManager
/**
* @author congtaowang
* @since 2021/1/15
*
*
* 网约车-出租车
*/
@Route(path = OchCommonConst.TAXI_DRIVER)
class TaxiDriverProvider : CommonServiceImpl() {
private val tag = TaxiDriverProvider::class.java.simpleName
private var ochTaxiFragment: TaxiFragment? = null
override fun init(context: Context) {
d(SceneConstant.M_TAXI + tag, "init")
}
override fun getFragment(): Fragment {
if (ochTaxiFragment == null) {
ochTaxiFragment = TaxiFragment()
}
OchAutopilotAnalytics.ochEventKey = TaxiAnalyticsManager
return ochTaxiFragment!!
}
override fun resetFragment() {
super.resetFragment()
OchAutopilotAnalytics.ochEventKey = null
ochTaxiFragment = null
}
}

26
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/CarHeartbeatReqBean.java
View File

@@ -1,26 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.och.taxi.constant.TaxiConst;
import java.util.UUID;
/**
* Created on 2021/9/16
*
* 上传车机心跳信息请求数据
*/
public class CarHeartbeatReqBean {
public String sn;
public double lon; //经度
public double lat; //纬度
public String msgId; //心跳信息唯一标识
public int interval; //上报间隔，单位秒，非必传，默认60秒
public CarHeartbeatReqBean(String sn, double lon, double lat) {
this.sn = sn;
this.lon = lon;
this.lat = lat;
this.msgId = UUID.randomUUID().toString();
this.interval = (int) (TaxiConst.LOOP_PERIOD_60S / 1000);
}
}

17
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/DriverServiceDataRespBean.java
View File

@@ -1,17 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
/**
* Created on 2021/9/17
*
* 司机运营数据返回数据结构
*/
public class DriverServiceDataRespBean extends BaseData {
public Result data;
public static class Result {
public long timeDuration; //当日在线时长，单位秒
public long orderNum; //当日完成订单数
}
}

14
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/DriverStatusUpdateReqBean.java
View File

@@ -1,14 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
*
* 状态更新请求数据结构
*/
public class DriverStatusUpdateReqBean {
public String sn;
public DriverStatusUpdateReqBean(String sn) {
this.sn = sn;
}
}

20
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderCancelReqBean.java
View File

@@ -1,20 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
*
* 司机取消订单请求的数据结构
*/
public class OrderCancelReqBean {
public String sn;
public String orderNo; //订单号（必须）
public int cancelType; //取消类型（必须）
public String cancelReason; //取消原因（必须）
public OrderCancelReqBean(String sn, String orderNo, int cancelType, String cancelReason) {
this.sn = sn;
this.orderNo = orderNo;
this.cancelType = cancelType;
this.cancelReason = cancelReason;
}
}

16
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderGrabReqBean.java
View File

@@ -1,16 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created on 2021/9/7
*
* （预约单）抢单动作的请求数据结构
*/
public class OrderGrabReqBean {
public String sn;
public String orderNo;
public OrderGrabReqBean(String sn, String orderNo) {
this.sn = sn;
this.orderNo = orderNo;
}
}

12
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderGrabRespBean.java
View File

@@ -1,12 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
/**
* Created on 2021/9/7
*
* （预约单）抢单动作的返回数据结构
*/
public class OrderGrabRespBean extends BaseData {
public String data; // 暂不使用 返回的orderNo,不再是orderId
}

16
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderGrabStatusQueryRespBean.java
View File

@@ -1,16 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
/**
* Created on 2021/9/7
*
* （预约单）查询抢单结果的返回数据结构
*/
public class OrderGrabStatusQueryRespBean extends BaseData {
public Result data;
public static class Result {
public int grabStatus; //0:抢单中; 1:抢单结束，匹配; 2:抢单结束，匹配到其他司机；3:订单已取消；4:非法，不是选择的自己
}
}

17
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderQueryReqBean.java
View File

@@ -1,17 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
*
* 查询订单信息请求数据结构
*/
public class OrderQueryReqBean {
public String sn;
public String orderNo;
public OrderQueryReqBean(String sn, String orderNo) {
this.sn = sn;
this.orderNo = orderNo;
}
}

148
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderQueryRespBean.java
View File

@@ -1,148 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
import com.mogo.och.data.taxi.BaseOrderBean;
import java.util.List;
import java.util.Objects;
/**
* Created by pangfan on 2021/8/19
*
* 查询订单返回数据结构
*/
public class OrderQueryRespBean extends BaseData {
public Result data;
public static class Result extends BaseOrderBean implements Comparable<Result>{
// 订单类型
public int orderType; //1即时单 2预约单
// 订单运营类型 （9出租车，10小巴）
public int businessType;
// 起始站点id
public int startSiteId;
// 起始站点名称
public String startSiteAddr;
// 起始站点坐标
public List<Double> startSitePoint; //wgs坐标，用于自动驾驶 [lon,lat]
public List<Double> startSiteGcjPoint; //高德坐标，用于本地计算距离 [lon,lat]
// 终点站点id
public int endSiteId;
// 终点站点名称
public String endSiteAddr;
// 终点站点坐标
public List<Double> endSitePoint; //wgs坐标，用于自动驾驶 [lon,lat]
public List<Double> endSiteGcjPoint; //高德坐标，用于计算距离 [lon,lat]
// 车牌号
public String carNumber;
//订单创建时间戳
public long createTime;
//开始服务时间戳：司机点击'开始服务'后订单状态更新成功的时间
public long startTime;
//预计用车时间：预约单=下单时的预约用车时间；即时单=派单成功的时间+预估的达到上车点的时间
public long bookingTime;
//乘客手机号
public String passengerPhone;
//订单多少乘客
public String passengerNum;
//线路轨迹相关字段
public long lineId = -1; //路线id，默认-1
public String lineName = ""; //路线名称，默认""
public String csvFileUrl = ""; //轨迹文件下载的cos url，默认“”
public String csvFileMd5 = ""; //轨迹文件md5，默认“”
public String txtFileUrl = ""; //打点文件下载的cos url，默认“”
public String txtFileMd5 = ""; //轨迹文件md5，默认“”
public long contrailSaveTime; //上传轨迹完成时间戳ms：用于MEC本地手动导入轨迹验证时不会被云端轨迹覆盖
public String carModel = ""; //[optional] 车型号（如红旗H9），默认“”，暂不加入校验逻辑、用于人工排查问题
public String csvFileUrlDPQP = ""; //轨迹文件下载的cos url，默认“”
public String csvFileMd5DPQP = ""; //轨迹文件md5，默认“”
public String txtFileUrlDPQP = ""; //打点文件下载的cos url，默认“”
public String txtFileMd5DPQP = ""; //轨迹文件md5，默认“”
public long contrailSaveTimeDPQP; //上传轨迹完成时间戳ms：用于MEC本地手动导入轨迹验证时不会被云端轨迹覆盖
// !!!接口中暂无此字段，仅用于本地实现逻辑使用：起始站目的站距离km
public double travelDistance;
@Override
public String getEndSiteAddr() {
return endSiteAddr;
}
/**
* @param distance
*/
public void decreaseTravelDistance( double distance ) {
travelDistance = ( ( float ) distance / 1000f );
if ( travelDistance < 0 ) {
travelDistance = 0;
}
}
@Override
public int compareTo(Result o) {
boolean isEqual = this.orderNo.equals(o.orderNo);
return isEqual ? 0 : 1;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Result result = (Result) o;
return Objects.equals(orderNo, result.orderNo) &&
orderType == result.orderType &&
orderStatus == result.orderStatus &&
businessType == result.businessType;
}
@Override
public int hashCode() {
return Objects.hash(orderNo, orderType, orderStatus, businessType, startSiteId,
startSiteAddr, startSitePoint, startSiteGcjPoint, endSiteId, endSiteAddr,
endSitePoint, endSiteGcjPoint, carNumber, createTime, startTime, travelDistance);
}
@Override
public String toString() {
return "Result{" +
"orderNo='" + orderNo + '\'' +
", orderType=" + orderType +
", orderStatus=" + orderStatus +
", businessType=" + businessType +
", startSiteId=" + startSiteId +
", startSiteAddr='" + startSiteAddr + '\'' +
", startSitePoint=" + startSitePoint +
", startSiteGcjPoint=" + startSiteGcjPoint +
", endSiteId=" + endSiteId +
", endSiteAddr='" + endSiteAddr + '\'' +
", endSitePoint=" + endSitePoint +
", endSiteGcjPoint=" + endSiteGcjPoint +
", carNumber='" + carNumber + '\'' +
", createTime=" + createTime +
", startTime=" + startTime +
", bookingTime=" + bookingTime +
", passengerPhone='" + passengerPhone + '\'' +
", passengerNum='" + passengerNum + '\'' +
", lineId=" + lineId +
", lineName='" + lineName + '\'' +
", csvFileUrl='" + csvFileUrl + '\'' +
", csvFileMd5='" + csvFileMd5 + '\'' +
", txtFileUrl='" + txtFileUrl + '\'' +
", txtFileMd5='" + txtFileMd5 + '\'' +
", contrailSaveTime=" + contrailSaveTime +
", carModel='" + carModel + '\'' +
", csvFileUrlDPQP='" + csvFileUrlDPQP + '\'' +
", csvFileMd5DPQP='" + csvFileMd5DPQP + '\'' +
", txtFileUrlDPQP='" + txtFileUrlDPQP + '\'' +
", txtFileMd5DPQP='" + txtFileMd5DPQP + '\'' +
", contrailSaveTimeDPQP=" + contrailSaveTimeDPQP +
", travelDistance=" + travelDistance +
'}';
}
}
}

23
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderRouteUpdateReqBean.java
View File

@@ -1,23 +0,0 @@
package com.mogo.och.taxi.bean;
import java.util.List;
/**
* Created by pangfan on 2021/8/19
*
* 订单状态更新请求数据结构
*/
public class OrderRouteUpdateReqBean {
public String orderNo;
public List<Result> points;
public static class Result {
public Double latitude;
public Double longitude;
}
public OrderRouteUpdateReqBean(String orderNo, List<Result> points) {
this.orderNo = orderNo;
this.points = points;
}
}

18
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrderStatusUpdateReqBean.java
View File

@@ -1,18 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
*
* 订单状态更新请求数据结构
*/
public class OrderStatusUpdateReqBean {
public String sn;
public String orderNo;
public int orderStatus;
public OrderStatusUpdateReqBean(String sn, String orderNo, int orderStatus) {
this.sn = sn;
this.orderNo = orderNo;
this.orderStatus = orderStatus;
}
}

36
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrdersInServiceQueryRespBean.java
View File

@@ -1,36 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
import java.util.List;
/**
* Created on 2021/9/8
*
* 查询全部服务中/待服务订单的返回数据
*/
public class OrdersInServiceQueryRespBean extends BaseData {
public Result data;
public static class Result {
public List<OrderQueryRespBean.Result> servicing; //服务中订单
public List<OrderQueryRespBean.Result> waitService; //待服务订单
@Override
public String toString() {
return "Result{" +
"servicing=" + servicing +
", waitService=" + waitService +
'}';
}
}
@Override
public String toString() {
return "OrdersInServiceQueryRespBean{" +
"data=" + data +
", code=" + code +
", msg='" + msg + '\'' +
'}';
}
}

19
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrdersListQueryReqBean.java
View File

@@ -1,19 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
*
* 查询订单列表请求数据结构
*/
public class OrdersListQueryReqBean {
public String sn;
public int page; //页码，从0开始
public int size; //每页条数
public OrdersListQueryReqBean(String sn, int page, int size) {
this.sn = sn;
this.page = page;
this.size = size;
}
}

16
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrdersListQueryRespBean.java
View File

@@ -1,16 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
import java.util.List;
/**
* Created by pangfan on 2021/8/19
*/
public class OrdersListQueryRespBean extends BaseData {
public Result data;
public static class Result {
public List<OrderQueryRespBean.Result> orders;
}
}

18
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/OrdersNewBookingQueryRespBean.java
View File

@@ -1,18 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
import java.util.List;
/**
* Created on 2021/9/8
*
* 查询新到的预约单的返回数据结构
*/
public class OrdersNewBookingQueryRespBean extends BaseData {
public Result data;
public static class Result {
public List<String> orders; // 返回的是order的orderNo集合， 不再是orderId集合
}
}

13
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/QueryOrderRouteResp.java
View File

@@ -1,13 +0,0 @@
package com.mogo.och.taxi.bean;
import com.amap.api.maps.model.LatLng;
import com.mogo.eagle.core.data.BaseData;
import java.util.List;
/**
* Created by pangfan on 2021/8/19
*/
public class QueryOrderRouteResp extends BaseData {
public List<LatLng> data;
}

12
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/TaxiDataBaseRespBean.java
View File

@@ -1,12 +0,0 @@
package com.mogo.och.taxi.bean;
import com.mogo.eagle.core.data.BaseData;
/**
* Created by pangfan on 2021/8/19
*
* 查询订单返回数据结构
*/
public class TaxiDataBaseRespBean extends BaseData {
public Object data;
}

23
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/TaxiOrPassengerReadyReqBean.java
View File

@@ -1,23 +0,0 @@
package com.mogo.och.taxi.bean;
/**
* Created by pangfan on 2021/8/19
* 司机端准备好或者乘客已验证上车请求参数
*/
public class TaxiOrPassengerReadyReqBean {
public String orderNo;
public String sn;
public TaxiOrPassengerReadyReqBean.Result loc;
public static class Result {
public Double lat;
public Double lon;
}
public TaxiOrPassengerReadyReqBean(String sn, String orderNo, TaxiOrPassengerReadyReqBean.Result point) {
this.sn = sn;
this.orderNo = orderNo;
this.loc = point;
}
}

14
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/bean/UpdateOrderDisAndTimeReqBean.java
View File

@@ -1,14 +0,0 @@
package com.mogo.och.taxi.bean;
public class UpdateOrderDisAndTimeReqBean {
public String orderNo; //订单号（必须）
public long distance; //剩余里程 单位米（必须）
public long duration; //剩余时间 单位秒（必须）
public UpdateOrderDisAndTimeReqBean(String orderNo, long distance, long duration) {
this.orderNo = orderNo;
this.distance = distance;
this.duration = duration;
}
}

16
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/callback/IOCHTaxiAutopilotPlanningCallback.java
View File

@@ -1,16 +0,0 @@
package com.mogo.och.taxi.callback;
import com.amap.api.maps.model.LatLng;
import com.mogo.eagle.core.data.map.MogoLocation;
import java.util.List;
/**
* @author: wangmingjun
* @date: 2021/11/1
*/
public interface IOCHTaxiAutopilotPlanningCallback {
void setLineMarker(LatLng startStation,LatLng endStation);
void routeResult(List<LatLng> routeArrivied,List<LatLng> routeArriving, MogoLocation location);
}

28
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/callback/ITaxiADASStatusCallback.java
View File

@@ -1,28 +0,0 @@
package com.mogo.och.taxi.callback;
/**
* Created on 2021/9/8
*
* Model->Presenter回调：ADAS相关（自动驾驶状态回调，到达终点等等）
*/
public interface ITaxiADASStatusCallback {
// 自动驾驶触发的已到达目的地：暂未用到
void onAutopilotArriveEnd();
// 自动驾驶可用状态
void onAutopilotEnable(boolean canStartAuto);
// 自动驾驶不可用状态
void onAutopilotDisable(boolean canStartAuto);
// 自动驾驶运行中
void onAutopilotRunning(boolean canStartAuto);
//人机共驾
void onManMachineCoDriving(boolean canStartAuto);
void updateAutopilotStatus(boolean canStartAuto);
//自驾返回失败
void onStartAdasFailure();
}

17
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/callback/ITaxiCarOperationalCallback.java
View File

@@ -1,17 +0,0 @@
package com.mogo.och.taxi.callback;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import java.util.List;
/**
* Created on 2021/9/8
*
* Model->Presenter回调：接单车状态变更 登录状态变更
*/
public interface ITaxiCarOperationalCallback {
void onServiceDataUpdate(long dailyTimeDuration, long dailyOrderNum);
void onOrdersListPageRefresh(List<OrderQueryRespBean.Result> ordersList);
}

13
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/callback/ITaxiControllerStatusCallback.java
View File

@@ -1,13 +0,0 @@
package com.mogo.och.taxi.callback;
import com.mogo.eagle.core.data.map.MogoLocation;
/**
* Created on 2021/9/10
*
* Model->Presenter回调：状态控制器监听（accOn、adas ui show、voice ui show、push ui show、v2x ui show等等）
*/
public interface ITaxiControllerStatusCallback {
//开始开启自动驾驶
void startOpenAutopilot();
}

55
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/callback/ITaxiOrderStatusCallback.java
View File

@@ -1,55 +0,0 @@
package com.mogo.och.taxi.callback;
import androidx.annotation.NonNull;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import java.util.List;
/**
* Created on 2021/9/8
*
* Model->Presenter回调：订单相关（进行中/待服务单变更，当前进行单状态变更，新到预约单，抢单，抢单结果状态等等）
*/
public interface ITaxiOrderStatusCallback {
// 进行中单变更：暂未用到
void onOrdersInServiceChanged(@NonNull List<OrderQueryRespBean.Result> inServiceList);
// 待服务单变更
void onOrdersWaitServiceChanged(@NonNull List<OrderQueryRespBean.Result> waitServiceList);
// 当前进行单状态变更：新到进行中订单、进行中单状态变更
void onCurrentOrderStatusChanged(OrderQueryRespBean.Result order);
// 当前订单取消完成：用于司机主动取消订单的结果反馈
void onCurrentOrderCancelDone();
// 待服务单被取消
void onOrderCancelDone(String orderNo);
// 当前订单route信息查询反馈
void onCurrentOrderRouteInfoGot(OrderQueryRouteInfoRespBean.Result routeInfo);
// 当前位置距离上车点的距离（米）、预估时间（秒）
void onCurrentOrderDistToStartChanged(long meters, long timeInSecond);
// 当前位置距离上车点的距离（米）、预估时间（秒）
void onCurrentOrderDistToEndChanged(long meters, long timeInSecond);
// 新到预约单
void onNewBookingOrderGot(OrderQueryRespBean.Result order);
// 执行抢单动作完成：可进入抢单中状态
void onGrabOrderExecuteDone();
// 抢到预约单
void onGrabOrderSuccess(OrderQueryRespBean.Result order);
// 未抢到预约单
void onGrabOrderFailed(OrderQueryRespBean.Result order);
// 司机已确认开启自动驾驶环境
void onDriverHasCheckedPilotCondition();
/**
* 导航到目的地
* @param isAmap 是否是高德导航
* @param isShow 是否显示导航地图（否播报声音）
*/
void onNaviToEnd(boolean isAmap, boolean isShow);
}

54
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/constant/TaxiConst.kt
View File

@@ -1,54 +0,0 @@
package com.mogo.och.taxi.constant
import com.mogo.commons.debug.DebugConfig
/**
* Created on 2021/12/6
*/
class TaxiConst {
companion object {
// 到达起始点围栏
const val ARRIVE_AT_START_STATION_DISTANCE = 15 //围栏由20m改为50m 再次改为15m
// 上报心跳轮询ms
const val LOOP_PERIOD_60S = 60 * 1000L
// 轮询查询进行中/待服务订单的间隔时间 2秒
const val LOOP_PERIOD_2S = 2 * 1000L
// 轮询查询新到预约单 1秒
const val LOOP_PERIOD_1S = 1 * 1000L
const val LOOP_DELAY = 100L
// 下发给MEC轨迹信息间隔时间 10秒
const val LOOP_PERIOD_10S = 10 * 1000L
// 尝试下发给MEC轨迹最多10次
const val LOOP_SEND_TRAJ_TIMES = 10
// 订单信息
const val SP_KEY_OCH_TAXI_ORDER = "SP_KEY_OCH_TAXI_ORDER"
//起点UUID
const val TAXI_START_MAP_MAKER = "taxi_start_map_maker"
//终点UUID
const val TAXI_END_MAP_MAKER = "taxi_end_map_maker"
//演示：V 测试：内测
const val DEMO_USER = "V"
const val TEST_USER = "内测"
// 实时计算当前剩余里程和时间 间隔 2秒
const val LOOP_CALCULATEROUTE_2S = 2 * 1000L
//总里程/平均车速。（bus的平均里程：25km/h，taxi的平均里程：38km/h），单位为：分钟，不足1分钟时，显示1分钟。
const val TAXI_AVERAGE_SPEED = 38
/**
* 订单起终点Marker类型
*/
const val TYPE_MARKER_TAXI_ORDER = "TYPE_MARKER_TAXI_ORDER"
const val TIMER_START_AUTOPILOT_INTERVAL = 20 * 1000L
}
}

54
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/constant/TaxiOrderCancelReasons.kt
View File

@@ -1,54 +0,0 @@
package com.mogo.och.taxi.constant
/**
* 司机端取消订单的原因定义
* Created on 2021/12/7
*
* * String int
* 进行中订单：
* 车况异常 0
* 设备异常 1
* 电量不足 2
* 身体不适 3
* 乘客未到 4
* 乘客中途下车 5
* 1099前都可用
*
* 待服务订单：
* 2000 车辆故障
* 2001 乘客联系取消
* 2002 行程冲突
* 2003 车电量不足
* 2004 其他
*/
enum class TaxiOrderCancelReasons(val type: Int, val msg: String) {
CarBroken(1000, "车况异常"),
DeviceBroken(1001, "设备异常"),
BatteryLow(1002, "电量不足"),
DriverIsIll(1003, "身体不适"),
PassengerNotArrive(1004, "乘客未到"),
PassengerStopOver(1005, "乘客中途下车"),
PassengerCancel(1006, "乘客联系安全员取消"),
UnContractPassenger(1007, "联系不上乘客"),
JourneyConflict(1008, "行程冲突"),
StartStationFaraway(1009,"距离过远 无法接单"),
Other( 1010, "其他原因"),
BookCarBroken(2000, "车辆故障"),
BookPassengerCancel(2001, "乘客联系取消"),
BookJourneyConflict(2002, "行程冲突"),
BookBatteryLow(2003, "车电量不足"),
BookOther(2004, "其他");
companion object {
@JvmStatic
fun getType(msg: String): Int {
for (value in values()) {
if (value.msg == msg) {
return value.type
}
}
return 0
}
}
}

11
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/constant/TaxiOrderTypeEnum.kt
View File

@@ -1,11 +0,0 @@
package com.mogo.och.taxi.constant
/**
* RoboTaxi订单类型声明
*
* Created on 2021/12/6
*/
enum class TaxiOrderTypeEnum(val type: Int) {
Instant(1), // 即时单
Reserved(2) // 预约单
}

1737
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/model/TaxiModel.java
View File

File diff suppressed because it is too large Load Diff

176
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/model/TaxiModelLoopManager.java
View File

@@ -1,176 +0,0 @@
package com.mogo.och.taxi.model;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI_P;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.och.taxi.constant.TaxiConst;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;
/**
* Created on 2021/9/10
*
* 管理轮询逻辑（订单轮询、新单轮询、新单抢单结果轮询等等）
*/
public class TaxiModelLoopManager {
private static final String TAG = TaxiModelLoopManager.class.getSimpleName();
private static final class SingletonHolder {
private static final TaxiModelLoopManager INSTANCE = new TaxiModelLoopManager();
}
public static TaxiModelLoopManager getInstance() {
return SingletonHolder.INSTANCE;
}
private Disposable mInAndWaitServiceDisposable; //进行中、待服务订单列表轮询
private Disposable mNewBookingOrderDisposable; //新到待抢预约单轮询
private Disposable mGrabResultDisposable; //抢单结果轮询
private Disposable mHeartbeatDisposable; //心跳轮询
private CompositeDisposable mCalculateRouteDisposable; //每隔2s计算一次剩余里程和时间
public void startInAndWaitOrdersLoop() {
if (mInAndWaitServiceDisposable != null && !mInAndWaitServiceDisposable.isDisposed()) {
return;
}
CallerLogger.i(M_TAXI + TAG, "startInAndWaitOrdersLoop()");
mInAndWaitServiceDisposable = Observable.interval(TaxiConst.LOOP_DELAY,
TaxiConst.LOOP_PERIOD_2S, TimeUnit.MILLISECONDS)
.map((aLong -> aLong + 1))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(aLong -> TaxiModel.getInstance().queryInAndWaitOrders());
}
public void stopInAndWaitOrdersLoop() {
if (mInAndWaitServiceDisposable != null) {
CallerLogger.i(M_TAXI + TAG, "stopInAndWaitOrdersLoop()");
mInAndWaitServiceDisposable.dispose();
mInAndWaitServiceDisposable = null;
}
}
public void startNewBookingOrderLoop() {
if (mNewBookingOrderDisposable != null && !mNewBookingOrderDisposable.isDisposed()) {
return;
}
CallerLogger.i(M_TAXI + TAG, "startNewBookingOrderLoop()");
mNewBookingOrderDisposable = Observable.interval(TaxiConst.LOOP_DELAY,
TaxiConst.LOOP_PERIOD_1S, TimeUnit.MILLISECONDS)
.map((aLong -> aLong + 1))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(aLong -> TaxiModel.getInstance().queryNewBookingOrder());
}
public void stopNewBookingOrderLoop() {
if (mNewBookingOrderDisposable != null) {
CallerLogger.i(M_TAXI + TAG, "stopNewBookingOrderLoop()");
mNewBookingOrderDisposable.dispose();
mNewBookingOrderDisposable = null;
}
}
public void startGrabResultLoop() {
if (mGrabResultDisposable != null && !mGrabResultDisposable.isDisposed()) {
return;
}
CallerLogger.i(M_TAXI + TAG, "startGrabResultLoop()");
mGrabResultDisposable = Observable.interval(TaxiConst.LOOP_DELAY,
TaxiConst.LOOP_PERIOD_1S, TimeUnit.MILLISECONDS)
.map((aLong -> aLong + 1))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(aLong -> TaxiModel.getInstance().queryOrderGrabStatus());
}
public void stopGrabResultLoop() {
if (mGrabResultDisposable != null) {
CallerLogger.i(M_TAXI + TAG, "stopGrabResultLoop()");
mGrabResultDisposable.dispose();
mGrabResultDisposable = null;
}
}
public void startHeartbeatLoop() {
if (mHeartbeatDisposable != null && !mHeartbeatDisposable.isDisposed()) {
return;
}
CallerLogger.i(M_TAXI + TAG, "startHeartbeatLoop()");
mHeartbeatDisposable = Observable.interval(TaxiConst.LOOP_DELAY,
TaxiConst.LOOP_PERIOD_60S, TimeUnit.MILLISECONDS)
.map((aLong -> aLong + 1))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(aLong -> TaxiModel.getInstance().runCarHeartbeat());
}
public void stopHeartbeatLoop() {
if (mHeartbeatDisposable != null) {
CallerLogger.i(M_TAXI + TAG, "stopHeartbeatLoop()");
mHeartbeatDisposable.dispose();
mHeartbeatDisposable = null;
}
}
public void startCalculateRouteInfoLoop() {
CallerLogger.i(M_TAXI + TAG, "startCalculateRouteInfoLoop()");
if (mCalculateRouteDisposable != null) return;
mCalculateRouteDisposable = new CompositeDisposable();
Disposable disposable = loopDynamicCalculateRouteInfo()
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
}
}).doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
}
})
.delay(TaxiConst.LOOP_CALCULATEROUTE_2S, TimeUnit.MILLISECONDS, true) // 设置delayError为true，表示出现错误的时候也需要延迟5s进行通知，达到无论是请求正常还是请求失败，都是5s后重新订阅，即重新请求。
.subscribeOn(Schedulers.io())
.repeat() // repeat保证请求成功后能够重新订阅。
.retry() // retry保证请求失败后能重新订阅
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
}
});
mCalculateRouteDisposable.add(disposable);
}
private Observable<Integer> loopDynamicCalculateRouteInfo(){
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
if (emitter.isDisposed()) return;
TaxiModel.getInstance().dynamicCalculateRouteInfo();
emitter.onComplete();
}
});
}
public void stopCalculateRouteInfoLoop() {
if (mCalculateRouteDisposable != null) {
CallerLogger.i(M_TAXI + TAG, "stopCalculateRouteInfoLoop()");
mCalculateRouteDisposable.dispose();
mCalculateRouteDisposable = null;
}
}
}

308
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/network/TaxiServiceApiNew.java
View File

@@ -1,308 +0,0 @@
package com.mogo.och.taxi.network;
import com.mogo.eagle.core.data.BaseData;
import com.mogo.och.taxi.bean.CarHeartbeatReqBean;
import com.mogo.och.taxi.bean.DriverServiceDataRespBean;
import com.mogo.och.taxi.bean.DriverStatusUpdateReqBean;
import com.mogo.och.taxi.bean.OrderCancelReqBean;
import com.mogo.och.taxi.bean.OrderGrabReqBean;
import com.mogo.och.taxi.bean.OrderGrabRespBean;
import com.mogo.och.taxi.bean.OrderGrabStatusQueryRespBean;
import com.mogo.och.taxi.bean.OrderQueryReqBean;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoReqBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import com.mogo.och.taxi.bean.OrderRouteUpdateReqBean;
import com.mogo.och.taxi.bean.OrderStatusUpdateReqBean;
import com.mogo.och.taxi.bean.OrdersInServiceQueryRespBean;
import com.mogo.och.taxi.bean.OrdersListQueryReqBean;
import com.mogo.och.taxi.bean.OrdersListQueryRespBean;
import com.mogo.och.taxi.bean.OrdersNewBookingQueryRespBean;
import com.mogo.och.taxi.bean.QueryOrderRouteResp;
import com.mogo.och.taxi.bean.TaxiDataBaseRespBean;
import com.mogo.och.taxi.bean.TaxiOrPassengerReadyReqBean;
import com.mogo.och.taxi.bean.UpdateOrderDisAndTimeReqBean;
import io.reactivex.Observable;
import retrofit2.http.Body;
import retrofit2.http.GET;
import retrofit2.http.Header;
import retrofit2.http.Headers;
import retrofit2.http.POST;
import retrofit2.http.Query;
/**
* Created by pangfan on 2021/8/19
*
* 网约车-出租车接口定义
*/
interface TaxiServiceApiNew {
/**
* 查询全部服务中/待服务订单（没有的时候返回code 0，空列表）
* @param sn
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @GET("/autopilot-car-hailing/api/v1/driver/orderInService/query")
@GET("/autopilot-car-hailing/order/v2/driver/taxi/orderInService/query")
Observable<OrdersInServiceQueryRespBean> queryOrdersInAndWaitService(@Header("appId") String appId
, @Header("ticket") String ticket, @Query("sn") String sn);
/**
* 查询新到的预约单
* @param sn
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @GET( "/autopilot-car-hailing/api/v1/driver/newBookingOrder/query" )
@GET( "/autopilot-car-hailing/order/v2/driver/taxi/newBookingOrder/query" )
Observable<OrdersNewBookingQueryRespBean> queryNewBookingOrder(@Header ("appId") String appId
,@Header("ticket") String ticket,@Query("sn") String sn);
/**
* (预约单)执行抢单动作
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/grabOrder" )
@POST( "/autopilot-car-hailing/order/v2/driver/taxi/grabOrder" )
Observable<OrderGrabRespBean> grabOrder(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderGrabReqBean data);
/**
* (预约单)查询抢单结果
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/grabStatus/query" )
@POST( "/autopilot-car-hailing/order/v2/driver/taxi/grabStatus/query" )
Observable<OrderGrabStatusQueryRespBean> queryOrderGrabStatus(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderGrabReqBean data);
/**
* 查询订单路径规划信息（到上车点、起始点间的距离和预估时间）
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/routeInfo/query" )
@POST( "/autopilot-car-hailing/order/v2/driver/taxi/routeInfo/query" )
Observable<OrderQueryRouteInfoRespBean> queryOrderRouteInfo(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderQueryRouteInfoReqBean data);
/**
* 通过orderId查询订单信息（用于本地已经有orderId时）
* @param data
* @return
* @deprecated v2.1_0930需求中暂不再使用此接口
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/queryOrderById" )
@POST( "/autopilot-car-hailing/order/v2/driver/taxi/queryOrderById" )
Observable<OrderQueryRespBean> queryOrderById(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderQueryReqBean data);
/**
* 查询服务中订单信息（用于本地无orderId时）
* 如果有多条，只会返回时间最近的一条
* @param sn
* @return
* @deprecated v2.1_0930需求中暂不再使用此接口
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @GET( "/autopilot-car-hailing/api/v1/driver/queryOrderInService" )
@GET( "/autopilot-car-hailing/order/v2/driver/taxi/queryOrderInService" )
Observable<OrderQueryRespBean> queryOrderInService(@Header ("appId") String appId,@Header("ticket") String ticket
,@Query("sn") String sn);
/**
* 取消订单
*/
@Headers({"Content-type:application/json;charset=UTF-8"})
// @POST("/autopilot-car-hailing/api/v1/driver/cancelOrder")
@POST("/autopilot-car-hailing/order/v2/driver/taxi/cancelOrder")
Observable<BaseData> cancelOrder(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderCancelReqBean data);
/**
* 订单列表获取
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/queryOrders" )
@POST( "/autopilot-car-hailing/order/v2/driver/taxi/queryOrders" )
Observable<OrdersListQueryRespBean> queryOrdersList(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrdersListQueryReqBean data);
/**
* 订单状态更新
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/order/updateStatus" )
// @POST( "/autopilot-car-hailing/order/v2/driver/taxi/order/updateStatus" )
@POST( "/autopilot-car-hailing/order/v2/vehicle/taxi/driver/updateStatus" )
Observable<BaseData> updateOrderStatus(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body OrderStatusUpdateReqBean data);
/**
* 车机端上传心跳数据（只在出车状态时上传）：包含高德坐标系经纬度
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/heartbeat" )
@POST( "/autopilot-car-hailing/location/v2/driver/taxi/heartbeat" )
Observable<BaseData> runCarHeartbeat(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body CarHeartbeatReqBean data);
/**
* 查询司机服务数据
* @param sn
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @GET( "/autopilot-car-hailing/api/v1/driver/serviceData/query" )
@GET( "/autopilot-car-hailing/order/v2/driver/taxi/serviceData/query" )
Observable<DriverServiceDataRespBean> queryServiceData(@Header ("appId") String appId
,@Header("ticket") String ticket,@Query("sn") String sn);
/**
* 上传工控机返回的全路径规划数据
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST("/autopilot-car-hailing/order/v2/driver/taxi/saveOrderRoute")
// @POST("/mock/268/autopilot-car-hailing/order/v2/driver/taxi/orderRoute")
Observable<BaseData> updateOrderRoute(@Header ("appId") String appId
, @Header("ticket") String ticket, @Body OrderRouteUpdateReqBean data);
/**
* 上报订单剩余里程和剩余时间
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST("/autopilot-car-hailing/order/v2/driver/taxi/reportOrderRemain")
Observable<BaseData> reportOrderRemain(@Header ("appId") String appId
, @Header("ticket") String ticket, @Body UpdateOrderDisAndTimeReqBean data);
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @GET( "/autopilot-car-hailing/api/v1/driver/serviceStatus/query" )
@GET( "/autopilot-car-hailing/order/v2/driver/taxi/orderRoute" )
Observable<QueryOrderRouteResp> queryOrderRoute(@Header ("appId") String appId
, @Header("ticket") String ticket, @Query("orderNo") String orderNo);
/**
* 司机端跳过乘客验证，订单状态流转为乘客已上车
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/ready/passenger" )
Observable<TaxiDataBaseRespBean> updatePassengerHasBoardedStatus(@Header ("appId") String appId
, @Header("ticket") String ticket, @Body TaxiOrPassengerReadyReqBean data);
/**
* 司机端确认可开启自动驾驶
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/ready/pilot" )
Observable<TaxiDataBaseRespBean> confirmAutopilotConditionByDriver(@Header ("appId") String appId
, @Header("ticket") String ticket,@Body TaxiOrPassengerReadyReqBean data);
/**
* 查询司机是否已确认可开启自动驾驶
* @param appId
* @param ticket
* @param orderNo
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@GET( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/pilot/status" )
Observable<TaxiDataBaseRespBean> queryPilotStatus(@Header ("appId") String appId
, @Header("ticket") String ticket,@Query("orderNo") String orderNo);
/**
* 开启自动驾驶成功
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/startServicePilot" )
Observable<TaxiDataBaseRespBean> startServicePilotDone(@Header ("appId") String appId
, @Header("ticket") String ticket,@Body TaxiOrPassengerReadyReqBean data);
/**
* 达到乘客上车点
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/passenger/arriveStartPoint" )
Observable<TaxiDataBaseRespBean> arrivedStartPoint(@Header ("appId") String appId
, @Header("ticket") String ticket,@Body TaxiOrPassengerReadyReqBean data);
/**
* 到达乘客目的地
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/arriveTerminal" )
Observable<TaxiDataBaseRespBean> arriveTerminal(@Header ("appId") String appId
, @Header("ticket") String ticket,@Body TaxiOrPassengerReadyReqBean data);
/**
* 订单完成
* @param appId
* @param ticket
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/orderCompleted" )
Observable<TaxiDataBaseRespBean> orderCompleted(@Header ("appId") String appId
, @Header("ticket") String ticket,@Body TaxiOrPassengerReadyReqBean data);
/**
* 暂停接单
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/serviceStatus/update" )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/stopOrderServing" )
Observable<BaseData> stopOrderServing(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body DriverStatusUpdateReqBean data);
/**
* 暂停接单
* @param data
* @return
*/
@Headers( {"Content-type:application/json;charset=UTF-8"} )
// @POST( "/autopilot-car-hailing/api/v1/driver/serviceStatus/update" )
@POST( "/autopilot-car-hailing/cab/flow/v1/driver/taxi/resetOrderServing" )
Observable<BaseData> resetOrderServing(@Header ("appId") String appId,@Header("ticket") String ticket
,@Body DriverStatusUpdateReqBean data);
}

500
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/network/TaxiServiceManager.kt
View File

@@ -1,500 +0,0 @@
package com.mogo.och.taxi.network
import android.content.Context
import com.mogo.cloud.passport.MoGoAiCloudClientConfig
import com.mogo.eagle.core.data.BaseData
import com.mogo.eagle.core.network.MoGoRetrofitFactory
import com.mogo.commons.storage.SharedPrefsMgr
import com.mogo.och.common.module.constant.OchCommonConst
import com.mogo.och.common.module.network.OchCommonServiceCallback
import com.mogo.och.common.module.network.OchCommonSubscribeImpl
import com.mogo.och.common.module.network.interceptor.transformTry
import com.mogo.och.data.taxi.OrderQueryRouteInfoReqBean
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean
import com.mogo.och.taxi.bean.*
import io.reactivex.Observable
/**
* Created by pangfan on 2021/8/19
*/
object TaxiServiceManager {
private var mOCHTaxiServiceApi: TaxiServiceApiNew =
MoGoRetrofitFactory.getInstance(OchCommonConst.getBaseUrl()).create(
TaxiServiceApiNew::class.java
)
/**
* 查询全部服务中/待服务订单列表
* @param context
* @param callback
*/
@JvmStatic
fun queryOrdersInAndWaitService(
context: Context,
callback: OchCommonServiceCallback<OrdersInServiceQueryRespBean>?
) {
mOCHTaxiServiceApi.queryOrdersInAndWaitService(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
SharedPrefsMgr.getInstance().sn
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrdersInAndWaitService",false))
}
/**
* 查询新到的预约单
* @param context
* @param callback
*/
@JvmStatic
fun queryNewBookingOrder(
context: Context,
callback: OchCommonServiceCallback<OrdersNewBookingQueryRespBean>?
) {
mOCHTaxiServiceApi.queryNewBookingOrder(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
SharedPrefsMgr.getInstance().sn
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryNewBookingOrder",false))
}
/**
* (预约单)执行抢单动作
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
fun grabOrder(
context: Context, orderNo: String?,
callback: OchCommonServiceCallback<OrderGrabRespBean>?
) {
mOCHTaxiServiceApi.grabOrder(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderGrabReqBean(
SharedPrefsMgr.getInstance().sn, orderNo
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "grabOrder"))
}
/**
* (预约单)查询抢单结果
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
fun queryOrderGrabStatus(
context: Context, orderNo: String?,
callback: OchCommonServiceCallback<OrderGrabStatusQueryRespBean>?
) {
mOCHTaxiServiceApi.queryOrderGrabStatus(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderGrabReqBean(
SharedPrefsMgr.getInstance().sn, orderNo
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrderGrabStatus",false))
}
/**
* 查询订单路径规划信息（到上车点、起始点间的距离和预估时间）
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
fun queryOrderRouteInfo(
context: Context, orderNo: String?,
callback: OchCommonServiceCallback<OrderQueryRouteInfoRespBean>?
) {
mOCHTaxiServiceApi.queryOrderRouteInfo(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderQueryRouteInfoReqBean(
SharedPrefsMgr.getInstance().sn, orderNo
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrderRouteInfo"))
}
/**
* 通过orderId查询订单信息（用于本地已经有orderId时）
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
@Deprecated("v2.1_0930需求中暂不再使用此接口")
fun queryOrderById(
context: Context, orderNo: String?,
callback: OchCommonServiceCallback<OrderQueryRespBean>?
) {
mOCHTaxiServiceApi.queryOrderById(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderQueryReqBean(
SharedPrefsMgr.getInstance().sn, orderNo
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrderById"))
}
/**
* 查询未完成态订单信息（用于本地无orderId时）
* 如果有多条，只会返回时间最近的一条
* @param context
* @param callback
*/
@JvmStatic
@Deprecated("v2.1_0930需求中暂不再使用此接口")
fun queryOrderInService(
context: Context,
callback: OchCommonServiceCallback<OrderQueryRespBean>?
) {
mOCHTaxiServiceApi.queryOrderInService(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
SharedPrefsMgr.getInstance().sn
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrderInService"))
}
/**
* 司机取消订单
* @param context
* @param orderNo
* @param cancelType
* @param cancelReason
* @param callback
*/
@JvmStatic
fun cancelOrder(
context: Context, orderNo: String?, cancelType: Int, cancelReason: String?,
callback: OchCommonServiceCallback<BaseData>?
) {
mOCHTaxiServiceApi.cancelOrder(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderCancelReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, cancelType, cancelReason
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "cancelOrder"))
}
/**
* 订单列表获取
* @param context
* @param page
* @param size
* @param callback
*/
@JvmStatic
fun queryOrdersList(
context: Context, page: Int, size: Int,
callback: OchCommonServiceCallback<OrdersListQueryRespBean>?
) {
mOCHTaxiServiceApi.queryOrdersList(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrdersListQueryReqBean(
SharedPrefsMgr.getInstance().sn, page, size
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrdersList"))
}
/**
* 订单状态更新
* @param context
* @param orderNo
* @param orderStatus
* @param callback
*/
@JvmStatic
fun updateOrderStatus(
context: Context, orderNo: String?, orderStatus: Int,
callback: OchCommonServiceCallback<BaseData>?
) {
mOCHTaxiServiceApi.updateOrderStatus(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderStatusUpdateReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, orderStatus
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "updateOrderStatus"))
}
/**
* 暂停接单
* @param context
* @param callback
*/
@JvmStatic
fun changeOrderServing(
context: Context, isOrdering: Boolean,
callback: OchCommonServiceCallback<BaseData>?
) {
val baseDataObservable: Observable<BaseData> = if (isOrdering) { // 正在接单去暂停
mOCHTaxiServiceApi.stopOrderServing(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
DriverStatusUpdateReqBean(
SharedPrefsMgr.getInstance().sn
)
).transformTry()
} else { // 没有接单去接单
mOCHTaxiServiceApi.resetOrderServing(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
DriverStatusUpdateReqBean(
SharedPrefsMgr.getInstance().sn
)
).transformTry()
}
baseDataObservable
.subscribe(OchCommonSubscribeImpl(context, callback, "updateDriverServiceStatus"))
}
/**
* 车机端上传心跳数据（只在出车状态时上传）：包含高德坐标系经纬度
* @param context
* @param lon
* @param lat
* @param callback
*/
@JvmStatic
fun runCarHeartbeat(
context: Context, lon: Double, lat: Double,
callback: OchCommonServiceCallback<BaseData>?
) {
mOCHTaxiServiceApi.runCarHeartbeat(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
CarHeartbeatReqBean(
SharedPrefsMgr.getInstance().sn, lon, lat
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "runCarHeartbeat",false))
}
/**
* 查询司机服务数据
* @param context
* @param callback
*/
@JvmStatic
fun queryDriverServiceData(
context: Context,
callback: OchCommonServiceCallback<DriverServiceDataRespBean>?
) {
mOCHTaxiServiceApi.queryServiceData(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
SharedPrefsMgr.getInstance().sn
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryDriverServiceData"))
}
/**
* 根据订单上传工控机返回的全路径规划数据
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
fun updateOrderRoute(
context: Context, orderNo: String?, points: List<OrderRouteUpdateReqBean.Result?>?,
callback: OchCommonServiceCallback<BaseData>?
) {
mOCHTaxiServiceApi.updateOrderRoute(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
OrderRouteUpdateReqBean(orderNo, points)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "updateOrderRoute"))
}
/**
* 上报剩余里程，时间
* @param context
* @param orderNo
* @param distance
* @param duration
* @param callback
*/
@JvmStatic
fun reportOrderRemain(
context: Context,
orderNo: String?,
distance: Long,
duration: Long,
callback: OchCommonServiceCallback<BaseData>?
) {
mOCHTaxiServiceApi.reportOrderRemain(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
UpdateOrderDisAndTimeReqBean(orderNo, distance, duration)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "reportOrderRemain"))
}
/**
* 查询订单全路径
* @param context
* @param orderNo
* @param callback
*/
@JvmStatic
fun queryOrderRoute(
context: Context,
orderNo: String?,
callback: OchCommonServiceCallback<QueryOrderRouteResp>?
) {
mOCHTaxiServiceApi.queryOrderRoute(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
orderNo
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryOrderRoute"))
}
@JvmStatic
fun confirmAutopilotConditionByDriver(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>?
) {
mOCHTaxiServiceApi.confirmAutopilotConditionByDriver(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "confirmAutopilotConditionByDriver"))
}
@JvmStatic
fun queryAutopilotStatus(
context: Context, orderNo: String?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>?
) {
mOCHTaxiServiceApi.queryPilotStatus(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
orderNo
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "queryAutopilotStatus"))
}
@JvmStatic
fun updatePassengerHasBoardedStatus(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>?
) {
mOCHTaxiServiceApi.updatePassengerHasBoardedStatus(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "updatePassengerHasBoardedStatus"))
}
@JvmStatic
fun startServicePilotDone(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>?
) {
mOCHTaxiServiceApi.startServicePilotDone(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "startServicePilotDone"))
}
@JvmStatic
fun arrivedStartPoint(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>?
) {
mOCHTaxiServiceApi.arrivedStartPoint(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "arrivedStartPoint"))
}
@JvmStatic
fun arriveTerminal(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>
) {
mOCHTaxiServiceApi.arriveTerminal(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "arriveTerminal"))
}
@JvmStatic
fun orderCompleted(
context: Context,
orderNo: String?,
loc: TaxiOrPassengerReadyReqBean.Result?,
callback: OchCommonServiceCallback<TaxiDataBaseRespBean>
) {
mOCHTaxiServiceApi.orderCompleted(
MoGoAiCloudClientConfig.getInstance().serviceAppId,
SharedPrefsMgr.getInstance().token,
TaxiOrPassengerReadyReqBean(
SharedPrefsMgr.getInstance().sn, orderNo, loc
)
)
.transformTry()
.subscribe(OchCommonSubscribeImpl(context, callback, "orderCompleted"))
}
}

76
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/presenter/NaviPresenter.java
View File

@@ -1,76 +0,0 @@
package com.mogo.och.taxi.presenter;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.lifecycle.LifecycleOwner;
import com.amap.api.maps.model.LatLng;
import com.mogo.commons.AbsMogoApplication;
import com.mogo.commons.mvp.Presenter;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.och.taxi.callback.IOCHTaxiAutopilotPlanningCallback;
import com.mogo.och.taxi.model.TaxiModel;
import com.mogo.och.taxi.ui.TaxiRottingNaviFragment;
import java.util.List;
/**
* @author congtaowang
* @since 2021/1/18
*
* 描述
*/
public class NaviPresenter extends Presenter<TaxiRottingNaviFragment> implements IOCHTaxiAutopilotPlanningCallback {
private static final String TAG = NaviPresenter.class.getSimpleName();
public NaviPresenter(TaxiRottingNaviFragment view) {
super(view);
TaxiModel.getInstance().init(AbsMogoApplication.getApp());
initListeners();
}
@Override
public void onCreate( @NonNull LifecycleOwner owner ) {
super.onCreate( owner );
CallerLogger.d( M_TAXI + TAG, " onCreate" );
}
@Override
public void onDestroy( @NonNull LifecycleOwner owner ) {
releaseListeners();
super.onDestroy( owner );
}
private void initListeners() {
TaxiModel.getInstance().setMoGoAutopilotPlanningListener(this);
}
private void releaseListeners() {
TaxiModel.getInstance().setMoGoAutopilotPlanningListener(null);
}
@Override
public void setLineMarker(LatLng startStation, LatLng endStation) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.setLineMarker(startStation, endStation);
}
}
},UiThreadHandler.MODE.QUEUE);
}
@Override
public void routeResult(List<LatLng> routeArrivied, List<LatLng> routeArriving, MogoLocation location) {
if(mView!=null) {
mView.routeResult(routeArrivied, routeArriving, location);
}
}
}

78
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/presenter/TaxiOperationalPresenter.java
View File

@@ -1,78 +0,0 @@
package com.mogo.och.taxi.presenter;
import android.os.Looper;
import com.mogo.commons.mvp.Presenter;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.taxi.callback.ITaxiCarOperationalCallback;
import com.mogo.och.taxi.model.TaxiModel;
import com.mogo.och.taxi.ui.TaxiPersonalDialogFragment;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.lifecycle.LifecycleOwner;
public class TaxiOperationalPresenter extends Presenter<TaxiPersonalDialogFragment>
implements ITaxiCarOperationalCallback {
public TaxiOperationalPresenter(TaxiPersonalDialogFragment view) {
super(view);
initListener();
}
private void initListener() {
TaxiModel.getInstance().setCarStatusCallback(this);
}
private void releaseListener(){
TaxiModel.getInstance().setCarStatusCallback(null);
}
@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
super.onDestroy(owner);
releaseListener();
}
// 获取全部订单列表
public void queryOrdersList(int page, int size) {
TaxiModel.getInstance().queryOrdersList(page, size);
}
@Override
public void onServiceDataUpdate(long dailyTimeDuration, long dailyOrderNum) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onServiceDataUpdate(dailyTimeDuration,dailyOrderNum);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onOrdersListPageRefresh(List<OrderQueryRespBean.Result> ordersList) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onOrdersListPageRefresh(ordersList);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
private void runOnUIThread( Runnable executor ) {
if ( executor == null ) {
return;
}
if ( Looper.myLooper() != Looper.getMainLooper() ) {
UiThreadHandler.post( executor );
} else {
executor.run();
}
}
}

522
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/presenter/TaxiPresenter.java
View File

@@ -1,522 +0,0 @@
package com.mogo.och.taxi.presenter;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.os.Build;
import android.os.Looper;
import android.util.ArrayMap;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.lifecycle.LifecycleOwner;
import com.mogo.commons.AbsMogoApplication;
import com.mogo.commons.mvp.Presenter;
import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager;
import com.mogo.eagle.core.function.call.och.CallerEagleBaseFunctionCall4OchManager;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.och.common.module.biz.login.ILoginCallback;
import com.mogo.och.common.module.biz.login.LoginStatusEnum;
import com.mogo.och.common.module.biz.login.LoginStatusManager;
import com.mogo.och.common.module.biz.login.OpenOrderStatusEnum;
import com.mogo.och.common.module.biz.order.OrderModel;
import com.mogo.och.common.module.manager.autopilot.OCHAdasAbilityManager;
import com.mogo.och.common.module.manager.logchainanalytic.OchChainLogManager;
import com.mogo.och.common.module.manager.autopilot.line.LineManager;
import com.mogo.och.common.module.voice.VoiceNotice;
import com.mogo.och.data.bean.LineInfo;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import com.mogo.och.taxi.callback.ITaxiADASStatusCallback;
import com.mogo.och.taxi.callback.ITaxiControllerStatusCallback;
import com.mogo.och.taxi.callback.ITaxiOrderStatusCallback;
import com.mogo.och.taxi.constant.TaxiConst;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.model.TaxiModel;
import com.mogo.och.taxi.ui.TaxiFragment;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* @author congtaowang
* @since 2021/1/18
* <p>
* 描述
*/
public class TaxiPresenter extends Presenter<TaxiFragment> implements ITaxiADASStatusCallback,
ITaxiOrderStatusCallback, ITaxiControllerStatusCallback, ILoginCallback {
private static final String TAG = TaxiPresenter.class.getSimpleName();
public TaxiPresenter(TaxiFragment view) {
super(view);
TaxiModel.getInstance().init(AbsMogoApplication.getApp());
OCHAdasAbilityManager.getInstance().init(AbsMogoApplication.getApp());
initListeners();
}
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
super.onCreate(owner);
CallerLogger.d(M_TAXI + TAG, "网约车-onCreate");
}
@Override
public void onDestroy(@NonNull LifecycleOwner owner) {
super.onDestroy(owner);
CallerLogger.d(M_TAXI + TAG, "网约车-onDestroy");
releaseListeners();
TaxiModel.getInstance().release();
}
private void initListeners() {
TaxiModel.getInstance().setADASStatusCallback(this);
TaxiModel.getInstance().setControllerStatusCallback(this);
TaxiModel.getInstance().setOrderStatusCallback(this);
LoginStatusManager.INSTANCE.addListener(TAG,this);
}
private void releaseListeners() {
TaxiModel.getInstance().setADASStatusCallback(null);
TaxiModel.getInstance().setControllerStatusCallback(null);
TaxiModel.getInstance().setOrderStatusCallback(null);
LoginStatusManager.INSTANCE.removeListener(TAG);
OCHAdasAbilityManager.getInstance().release();
}
private void runOnUIThread(Runnable executor) {
if (executor == null) {
return;
}
if (Looper.myLooper() != Looper.getMainLooper()) {
UiThreadHandler.post(executor);
} else {
executor.run();
}
}
/**
* 开启自动驾驶 自驾模式
*/
public void startAutoPilot() {
TaxiModel.getInstance().startAutoPilot();
}
/**
* 人工模式
*/
public void startManualDrive() {
TaxiModel.getInstance().startServicePilotDone();
}
/**
* 跳过乘客验证环节
*/
public void jumpPassengerCheckDone() {
TaxiModel.getInstance().jumpPassengerCheckDone();
}
/**
* 司机确认车辆环境可开启自动驾驶
*/
public void confirmAutopilotConditionByDriver() {
TaxiModel.getInstance().confirmAutopilotConditionByDriver();
}
// 更新接单状态
public void updateCarStatus() {
TaxiModel.getInstance().updateCarStatus();
}
// 获取当前订单状态
public TaxiOrderStatusEnum getCurOrderStatus() {
return TaxiModel.getInstance().getCurOrderStatus();
}
// 取消当前订单
public void cancelCurOrder(int reasonType, String reason) {
TaxiModel.getInstance().cancelCurrentOrder(reasonType, reason);
}
// 取消待服务中订单
public void cancelOrderById(String orderNo, int reasonType, String reason) {
TaxiModel.getInstance().cancelOrderById(orderNo, reasonType, reason);
}
// 查询当前订单route信息：预估时间、里程等
public void queryCurOrderRouteInfo() {
TaxiModel.getInstance().queryCurOrderRouteInfo();
}
// 执行抢单动作
public void grabOrder() {
TaxiModel.getInstance().grabOrder();
}
// 关闭新到预约单
public void cancelNewBookingOrder() {
TaxiModel.getInstance().cancelNewBookingOrder();
}
//更新订单已完成状态
public void completeOrderService() {
TaxiModel.getInstance().orderCompleted();
}
// 登出
public void logout() {
TaxiModel.getInstance().logout();
}
//导航去订单目的地
public void startNaviToEndStation(boolean isShow) {
TaxiModel.getInstance().startNaviToEndStation(isShow);
}
public void reportToEndDisAndTime(long lastSumLength, long duration) {//米/秒
TaxiModel.getInstance().reportOrderRemain(lastSumLength, duration);
}
public void closeOrderByMan() {
TaxiModel.getInstance().arriveTerminal();
}
@Override
public void onAutopilotArriveEnd() {
}
@Override
public void onAutopilotEnable(boolean canStartAuto) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateAutopilotStatus(
IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_ENABLE,canStartAuto);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onAutopilotDisable(boolean canStartAuto) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateAutopilotStatus(
IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE,canStartAuto);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onAutopilotRunning(boolean canStartAuto) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateAutopilotStatus(
IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING,canStartAuto);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onManMachineCoDriving(boolean canStartAuto) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onManMachineCoDriving(IMoGoAutopilotStatusListener.STATUS_PARALLEL_DRIVING,canStartAuto);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void updateAutopilotStatus(boolean canStartAuto) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateAutopilotStatus(
CallerAutoPilotStatusListenerManager.INSTANCE.getState(),canStartAuto);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onStartAdasFailure() {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.stopAnimAndUpdateBtnStatus();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onOrdersInServiceChanged(@NonNull @NotNull List<OrderQueryRespBean.Result> inServiceList) {
}
@Override
public void onOrdersWaitServiceChanged(@NonNull @NotNull List<OrderQueryRespBean.Result> waitServiceList) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onOrdersWaitServiceChanged(waitServiceList);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@RequiresApi(api = Build.VERSION_CODES.P)
@Override
public void onCurrentOrderStatusChanged(OrderQueryRespBean.Result order) {
OchChainLogManager.writeChainLog("订单信息变化",order.toString());
OrderModel.INSTANCE.invokeListener(order);
CallerLogger.d(M_TAXI + TAG, "order = " + order.toString());
LineManager.setLineInfo(new LineInfo(order.lineId,order.lineName,new ArrayMap<>()));
if (TaxiOrderStatusEnum.UserArriveAtStart.getCode() == order.orderStatus) {
TaxiModel.getInstance().queryAutopilotStatus(true);
TaxiModel.getInstance().setStation();
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.setGuidShow();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
if (TaxiOrderStatusEnum.OnTheWayToEnd.getCode() == order.orderStatus) {
TaxiModel.getInstance().startDynamicCalculateRouteInfo();
TaxiModel.getInstance().setStation();
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateCtvAutopilotStatusTag(true);
CallerEagleBaseFunctionCall4OchManager.INSTANCE.updateOrderStatus(true);
mView.setGuidHide();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
if (TaxiOrderStatusEnum.ArriveAtEnd.getCode() == order.orderStatus ||
TaxiOrderStatusEnum.Cancel.getCode() == order.orderStatus ||
TaxiOrderStatusEnum.JourneyCompleted.getCode() == order.orderStatus) {
TaxiModel.getInstance().startOrStopCalculateRouteInfo(false);
TaxiModel.getInstance().cleanLineMarker();
TaxiModel.getInstance().cleanStation();
LineManager.setLineInfo(null);
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
/* 2023.12.18 1.去除"自驾/安全"模式选择，默认自驾模式且无需点击；
* 2.server去除订单流转对"安全确认"的限制（读写接口默认反馈ok，但"开启自动驾驶成功"不再限制）
*/
mView.updateCtvAutopilotStatusTag(false);
if (TaxiOrderStatusEnum.ArriveAtEnd.getCode() == order.orderStatus) {
CallerEagleBaseFunctionCall4OchManager.INSTANCE.updateOrderStatus(false);
}
}
}
}, UiThreadHandler.MODE.QUEUE);
}
if (TaxiOrderStatusEnum.Cancel.getCode() == order.orderStatus) {
VoiceNotice.showNotice("乘客已取消行程");
}
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.updateCurrentOrderStatusChanged(order);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onCurrentOrderCancelDone() {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onCurrentOrderCancelDone();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onOrderCancelDone(String orderNo) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onOrderCancelDone(orderNo);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onCurrentOrderRouteInfoGot(OrderQueryRouteInfoRespBean.Result routeInfo) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
OchChainLogManager.writeChainLog(
"到达目的地计算距离和时间",
"距离："+routeInfo.distanceToEnd+" 时间："+routeInfo.durationToEnd
);
mView.onCurrentOrderRouteInfoGot(routeInfo);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onCurrentOrderDistToStartChanged(long meters, long timeInSecond) {
}
@Override
public void onCurrentOrderDistToEndChanged(long meters, long timeInSecond) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onCurrentOrderDistToEndChanged(meters, timeInSecond);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onNewBookingOrderGot(OrderQueryRespBean.Result order) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onNewBookingOrderGot(order);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onGrabOrderExecuteDone() {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onGrabOrderExecuteDone();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onGrabOrderSuccess(OrderQueryRespBean.Result order) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onGrabOrderSuccess(order);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onGrabOrderFailed(OrderQueryRespBean.Result order) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onGrabOrderFailed(order);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onDriverHasCheckedPilotCondition() {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onCheckPilotConditionSafe();
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onNaviToEnd(boolean isAmap, boolean isShow) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.onNaviToEnd(isAmap, isShow);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void startOpenAutopilot() {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if(mView!=null) {
mView.startOrStopLoadingAnim(true);
}
}
}, UiThreadHandler.MODE.QUEUE);
}
@Override
public void onStatusChange(LoginStatusEnum currentStatus) {
//设置 是否启动订单轮训
TaxiModel.getInstance().startOrStopOrderLoop(LoginStatusManager.isLogin()&&LoginStatusManager.isOpenOrderType());
// 设置当前用户角色
String role = "";
switch (LoginStatusManager.getPurpose()) {
case DEMO:{
role = TaxiConst.DEMO_USER;
}
case TEST:{
role = TaxiConst.TEST_USER;
}
}
}
@Override
public void onOpenOrderStatusEnumChange(OpenOrderStatusEnum businessEnum) {
if(businessEnum==OpenOrderStatusEnum.Ordering){
TaxiModel.getInstance().startOrStopOrderLoop(LoginStatusManager.isLogin()&&LoginStatusManager.isOpenOrderType());
}
}
}

309
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/BaseTaxiTabFragment.java
View File

@@ -1,309 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.och.taxi.constant.TaxiConst.TIMER_START_AUTOPILOT_INTERVAL;
import android.content.Context;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentTransaction;
import com.mogo.commons.mvp.IView;
import com.mogo.commons.mvp.MvpFragment;
import com.mogo.commons.mvp.Presenter;
import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
import com.mogo.eagle.core.function.api.och.toolkit.IToolKitItemClickListener;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager;
import com.mogo.eagle.core.function.call.autopilot.CallerAutopilotRecordListenerManager;
import com.mogo.eagle.core.function.call.hmi.CallerHmiViewControlListenerManager;
import com.mogo.eagle.core.function.call.och.CallerEagleBaseFunctionCall4OchManager;
import com.mogo.eagle.core.function.hmi.map.MapContainerLayout;
import com.mogo.eagle.core.function.view.MapRoamView;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.map.listener.IMogoMapListener;
import com.mogo.och.common.module.wigets.map.drawline.LineView;
import com.mogo.och.taxi.R;
import java.lang.ref.WeakReference;
/**
* 网约车基础Fragment，主要负责布局通用界面，处理站点面板和通话面板互斥情况
* <p>
* 部分业务放在了此处处理
*
* @author tongchenfei
*/
public abstract class BaseTaxiTabFragment<V extends IView, P extends Presenter<V>> extends MvpFragment<V, P> implements IMogoMapListener {
private static final String TAG = "BaseOchFragment";
private FrameLayout flNaviPanelContainer;
private ImageView mCloseNaviIcon;
protected TaxiAmapNaviFragment ochAmapNaviFragment = null;
protected TaxiRottingNaviFragment taxiRottingNaviFragment = null;
private MapRoamView mapRoamView;
private MapContainerLayout mapContainerLayout;
private final Handler mHandler = new Handler(Looper.getMainLooper());
private String runningTaskGateWay = "RUNNINGTASKGATEWAY";
private String lineView = "LINEVIEW";
// 查看运营情况 点击账户信息右边的箭头展示
private WeakReference<TaxiPersonalDialogFragment> personalDialogFragment = null;
@Override
protected int getLayoutId() {
return R.layout.taxi_base_fragment;
}
@Override
protected void initViews() {
mapContainerLayout = findViewById(R.id.mapContainerLayout);
mapRoamView = findViewById(R.id.mapRoamView);
updateCtvAutopilotStatusTag(false);
mCloseNaviIcon = findViewById(R.id.taxi_close_navi_icon);
flNaviPanelContainer = findViewById(R.id.module_mogo_och_navi_panel_container);
CallerHmiViewControlListenerManager.INSTANCE.invokeMainPageViewVisible(View.VISIBLE);
onAutopilotStatusChanged(CallerAutoPilotStatusListenerManager.INSTANCE.getState(), CallerAutoPilotControlManager.INSTANCE.isCanStartAutopilot(false, 0));
mCloseNaviIcon.setOnClickListener(v -> {
showAmapNaviToStationFragment(false);
showRottingToStationFragment(false);
});
if (getContext() != null) {
CallerEagleBaseFunctionCall4OchManager.INSTANCE.addSingleToolKitDefaultItem(runningTaskGateWay, "运营看板", R.drawable.common_biz_operation, 4);
CallerEagleBaseFunctionCall4OchManager.INSTANCE.addToolKitDefaultItemClickListener(runningTaskGateWay, new IToolKitItemClickListener() {
@Override
public void onItemClick(@NonNull String toolTag, @Nullable Context ctx) {
if (runningTaskGateWay.equals(toolTag)) {
CallerLogger.d(TAG,"runningTaskGateWay:"+runningTaskGateWay+"---toolTag:"+toolTag);
personalDialogFragment = new WeakReference<>(new TaxiPersonalDialogFragment());
FragmentActivity activity = getActivity();
if (activity != null) {
personalDialogFragment.get().show(activity.getSupportFragmentManager(), "service_data");
}
}
}
});
CallerEagleBaseFunctionCall4OchManager.INSTANCE.addSingleToolKitCustomItem(lineView, new LineView(getContext()), 10);
}
}
@Override
protected void initViews(Bundle savedInstanceState) {
super.initViews(savedInstanceState);
mapContainerLayout.onCreate(savedInstanceState);
mapRoamView.onCreate(savedInstanceState);
}
@Override
public void onResume() {
super.onResume();
mapContainerLayout.onResume();
mapRoamView.onResume();
}
@Override
public void onPause() {
super.onPause();
mapContainerLayout.onPause();
mapRoamView.onPause();
}
protected void onChangeOperationStatus() {
}
@Override
public void onLowMemory() {
super.onLowMemory();
mapContainerLayout.onLowMemory();
mapRoamView.onLowMemory();
}
@Override
public void onSaveInstanceState(@NonNull Bundle outState) {
super.onSaveInstanceState(outState);
mapContainerLayout.onSaveInstanceState(outState);
mapRoamView.onSaveInstanceState(outState);
}
@Override
public void onDestroyView() {
mapContainerLayout.onDestroy();
mapRoamView.onDestroy();
super.onDestroyView();
flNaviPanelContainer = null;
mapContainerLayout = null;
mapRoamView = null;
mCloseNaviIcon = null;
ochAmapNaviFragment = null;
taxiRottingNaviFragment = null;
CallerAutopilotRecordListenerManager.INSTANCE.removeListener(TAG);
}
@Override
public void onDestroy() {
super.onDestroy();
}
public void onAutopilotStatusChanged(int status, boolean canStart) {
UiThreadHandler.post(new Runnable() {
@Override
public void run() {
if (isStarting && IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING != status) {
// 1. 主动开启自动驾驶中，不为2（为0、1）则继续loading
return;
}
if (isStarting && IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING == status) {
// 2. 主动开启自动驾驶中，为2则停止loading，并isStarting = false
startAutopilotDone(true);
return;
}
// 3. 其他过程直接更新
startOrStopLoadingAnim(false);
autopilotStatusAnimchanged(status, canStart);
}
}, UiThreadHandler.MODE.QUEUE);
}
public void stopAnimAndUpdateBtnStatus() {
startOrStopLoadingAnim(false);
startAutopilotDone(false);
}
public void onManMachineCoDriving(int manMachineCoDriving, boolean canStartAuto) {
autopilotStatusAnimchanged(manMachineCoDriving, canStartAuto);
}
public void updateCtvAutopilotStatusTag(boolean tag) {
}
public void onCheckPilotConditionSafe() {
updateCtvAutopilotStatusTag(true);
updateOrderBottomBtnUI();
}
protected abstract void updateOrderBottomBtnUI();
public void autopilotStatusAnimchanged(int status, boolean canStart) {
}
private void startAutopilotDone(boolean success) {
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
startOrStopLoadingAnim(false);
onAutopilotStatusChanged(CallerAutoPilotStatusListenerManager.INSTANCE.getState(), CallerAutoPilotControlManager.INSTANCE.isCanStartAutopilot(false, 0));
}
}, 1000L);
}
public boolean isStarting = false;
public void startOrStopLoadingAnim(boolean start) {
if (start) {
isStarting = true;
startingAutoApilotCountDown();
} else {
isStarting = false;
}
}
private void startingAutoApilotCountDown() {
UiThreadHandler.postDelayed(new Runnable() {
@Override
public void run() { //未启动成功10s后做处理
if (isStarting) { //判断动画是否在进行
//并且根据状态来设置自动驾驶启动成功还是失败
startAutopilotDone(CallerAutoPilotStatusListenerManager.INSTANCE.getState()
== IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING);
}
}
}, TIMER_START_AUTOPILOT_INTERVAL);
}
protected void showAmapNaviToStationFragment(boolean isShow) {
FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
closeAmapViewIFHadeAdd();
if (isShow) {
closeRouteViewIFHadeAdd();
ochAmapNaviFragment = TaxiAmapNaviFragment.newInstance();
if (ochAmapNaviFragment.isAdded()) {
return;
}
transaction.add(R.id.module_mogo_och_navi_panel_container, ochAmapNaviFragment).show(ochAmapNaviFragment);
transaction.commitAllowingStateLoss();
mCloseNaviIcon.setVisibility(View.VISIBLE);
flNaviPanelContainer.setVisibility(View.VISIBLE);
} else {
mCloseNaviIcon.setVisibility(View.GONE);
flNaviPanelContainer.setVisibility(View.INVISIBLE);
}
}
private void closeAmapViewIFHadeAdd() {
if (ochAmapNaviFragment != null) {
FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
ochAmapNaviFragment.onDestroy();
transaction.remove(ochAmapNaviFragment);
transaction.commitAllowingStateLoss();
ochAmapNaviFragment = null;
}
}
private void closeRouteViewIFHadeAdd() {
if (taxiRottingNaviFragment != null) {
FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
taxiRottingNaviFragment.onDestroy();
transaction.remove(taxiRottingNaviFragment);
transaction.commitAllowingStateLoss();
taxiRottingNaviFragment = null;
}
}
protected void showRottingToStationFragment(boolean isShow) {
FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
if (isShow) {
closeAmapViewIFHadeAdd();
// if (ochNaviFragment == null){
taxiRottingNaviFragment = TaxiRottingNaviFragment.newInstance();
// }
if (taxiRottingNaviFragment.isAdded()) {
return;
}
transaction.add(R.id.module_mogo_och_navi_panel_container, taxiRottingNaviFragment).show(taxiRottingNaviFragment);
transaction.commitAllowingStateLoss();
mCloseNaviIcon.setVisibility(View.VISIBLE);
flNaviPanelContainer.setVisibility(View.VISIBLE);
} else {
closeRouteViewIFHadeAdd();
mCloseNaviIcon.setVisibility(View.GONE);
flNaviPanelContainer.setVisibility(View.INVISIBLE);
}
}
public abstract void startNaviToEndStation(boolean isShow);
public void setGuidShow() {
}
public void setGuidHide() {
}
}

50
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/BaseTaxiUIFragment.java
View File

@@ -1,50 +0,0 @@
package com.mogo.och.taxi.ui;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
/**
* @author: wangmingjun
* @date: 2021/9/9
*/
public abstract class BaseTaxiUIFragment extends Fragment {
private View mRootView;
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
if (mRootView == null) {
mRootView = inflater.inflate(getLayoutId(), container, false);
} else {
ViewGroup viewGroup = (ViewGroup) mRootView.getParent();
if (viewGroup != null) {
viewGroup.removeView(mRootView);
}
}
initViews(mRootView);
initViews(savedInstanceState);
return mRootView;
}
/**
* 布局资源
*
* @return
*/
protected abstract int getLayoutId();
protected abstract void initViews(View view);
protected void initViews(Bundle savedInstanceState) {
}
@Override
public void onDestroy() {
super.onDestroy();
mRootView = null;
}
}

23
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/ITaxiMapDirectionView.java
View File

@@ -1,23 +0,0 @@
package com.mogo.och.taxi.ui;
/**
* @author xiaoyuzhou
* @date 2021/6/24 11:33 上午
*/
public interface ITaxiMapDirectionView {
/**
* 绘制路径线
*/
void drawablePolyline();
/**
* 清除路径线
*/
void clearPolyline();
/**
* 设置路径中起终点marker
*/
void setLineMarker();
}

13
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/ITaxiView.java
View File

@@ -1,13 +0,0 @@
package com.mogo.och.taxi.ui;
import com.mogo.commons.mvp.IView;
public
/**
* @author congtaowang
* @since 2021/1/18
*
* 描述
*/
interface ITaxiView extends IView {
}

220
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiAmapNaviFragment.java
View File

@@ -1,220 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.os.Bundle;
import android.view.View;
import com.amap.api.navi.AMapNaviViewListener;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.och.common.module.map.AmapNaviToDestinationModel;
import com.mogo.och.common.module.map.ICommonNaviChangedCallback;
import com.mogo.och.common.module.map.CommonAmapNaviVIew;
import com.mogo.och.taxi.R;
/**
* @author: wangmingjun
* @date: 2021/11/30
*/
public class TaxiAmapNaviFragment extends BaseTaxiUIFragment implements AMapNaviViewListener {
private CommonAmapNaviVIew mAMapNaviView;
private ICommonNaviChangedCallback mNaviToStartInfoCallback;
public static TaxiAmapNaviFragment newInstance() {
Bundle args = new Bundle();
TaxiAmapNaviFragment fragment = new TaxiAmapNaviFragment();
fragment.setArguments(args);
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_amap_navi_view;
}
@Override
protected void initViews(View view) {
mAMapNaviView = view.findViewById(R.id.navi_view);
}
@Override
protected void initViews(Bundle savedInstanceState) {
super.initViews(savedInstanceState);
if (mAMapNaviView != null) {
mAMapNaviView.onCreate(savedInstanceState);
}
}
@Override
public void onResume() {
super.onResume();
if (mAMapNaviView != null) {
mAMapNaviView.onResume();
}
}
@Override
public void onPause() {
super.onPause();
if (mAMapNaviView != null) {
mAMapNaviView.onPause();
}
}
@Override
public void onDestroy() {
super.onDestroy();
AmapNaviToDestinationModel.getInstance(getContext()).setVoiceIsMute(false);
if (mAMapNaviView != null){
mAMapNaviView.onDestroy();
}
if (mNaviToStartInfoCallback != null){
mNaviToStartInfoCallback = null;
}
}
@Override
public void onNaviSetting() {
//底部导航设置点击回调
}
@Override
public void onNaviCancel() {
}
@Override
public void onNaviMapMode(int naviMode) {
//导航态车头模式，0:车头朝上状态；1:正北朝上模式。
}
@Override
public void onNaviTurnClick() {
//转弯view的点击回调
}
@Override
public void onNextRoadClick() {
//下一个道路View点击回调
}
@Override
public void onScanViewButtonClick() {
//全览按钮点击回调
}
@Override
public void onLockMap(boolean isLock) {
//锁地图状态发生变化时回调
}
@Override
public void onNaviViewLoaded() {
CallerLogger.d(M_TAXI + "wlx", "导航页面加载成功");
CallerLogger.d(M_TAXI + "wlx", "请不要使用AMapNaviView.getMap().setOnMapLoadedListener();会overwrite导航SDK内部画线逻辑");
}
@Override
public void onMapTypeChanged(int i) {
}
@Override
public void onNaviViewShowMode(int i) {
}
@Override
public boolean onNaviBackClick() {
return false;
}
/**
* 车道信息说明：
* <p>
* 0xFF, 无对应车道
* 0, 直行
* 1, 左转
* 2, 直行+左转
* 3, 右转
* 4, 直行+右转
* 5, 左掉头
* 6, 左转+右转
* 7, 直行+左转+右转
* 8, 右掉头
* 9, 直行+左掉头
* 10, 直行+右掉头
* 11, 左转+左掉头
* 12, 右转+右掉头
* 13, 直行+扩展
* 14, 左转+左掉头+扩展
* 15, 保留
* 16, 直行+左转+左掉头
* 17, 右转+左掉头
* 18, 左转+右转+左掉头
* 19, 直行+右转+左掉头
* 20, 左转+右掉头
* 21, 公交车道
* 22, 空车道
* 23 可变车道
*/
String[] array = {
"直行车道"
, "左转车道"
, "左转或直行车道"
, "右转车道"
, "右转或直行车道"
, "左掉头车道"
, "左转或者右转车道"
, " 左转或右转或直行车道"
, "右转掉头车道"
, "直行或左转掉头车道"
, "直行或右转掉头车道"
, "左转或左掉头车道"
, "右转或右掉头车道"
, "直行并且车道扩展"
, "左转+左掉头+扩展"
, "不可以选择该车道"
, "直行+左转+左掉头车道"
, "右转+左掉头"
, "左转+右转+左掉头"
, "直行+右转+左掉头"
, "左转+右掉头"
, "公交车道"
, "空车道"
, "可变车道"
};
String[] actions = {
"直行"
, "左转"
, "左转或直行"
, "右转"
, "右转或这行"
, "左掉头"
, "左转或者右转"
, " 左转或右转或直行"
, "右转掉头"
, "直行或左转掉头"
, "直行或右转掉头"
, "左转或左掉头"
, "右转或右掉头"
, "直行并且车道扩展"
, "左转+左掉头+扩展"
, "不可以选择"
, "直行+左转+左掉头"
, "右转+左掉头"
, "左转+右转+左掉头"
, "直行+右转+左掉头"
, "左转+右掉头"
, "公交车道"
, "空车道"
, "可变车道"
};
}

815
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiBeingServerdOrdersFragment.java
View File

@@ -1,815 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import static com.mogo.map.MogoMap.DEFAULT;
import android.app.Activity;
import android.graphics.Color;
import android.graphics.drawable.GradientDrawable;
import android.os.Build;
import android.os.Bundle;
import android.text.Html;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.annotation.RequiresApi;
import androidx.constraintlayout.widget.ConstraintLayout;
import com.amap.api.navi.model.NaviLatLng;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager;
import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager;
import com.mogo.eagle.core.function.hmi.ui.widget.ItinerarySummaryDialog;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.DateTimeUtils;
import com.mogo.eagle.core.utilcode.util.ToastUtils;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.map.overlay.IMoGoOverlayManager;
import com.mogo.map.overlay.core.Level;
import com.mogo.map.overlay.point.Point;
import com.mogo.och.common.module.manager.autopilot.location.OchLocationManager;
import com.mogo.och.common.module.map.AmapNaviToDestinationModel;
import com.mogo.och.common.module.map.ICommonNaviChangedCallback;
import com.mogo.och.common.module.utils.DateTimeUtil;
import com.mogo.och.common.module.utils.NumberFormatUtil;
import com.mogo.och.common.module.utils.OCHThreadPoolManager;
import com.mogo.och.common.module.utils.ResourcesUtils;
import com.mogo.och.common.module.voice.VoiceNotice;
import com.mogo.och.common.module.wigets.OCHCommitDialog;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.constant.TaxiConst;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import com.mogo.och.taxi.model.TaxiModel;
import com.mogo.skin.utils.SkinResources;
import java.util.Calendar;
import java.util.List;
/**
* @author congtaowang
* @since 2021/1/18
* 正在进行中订单
*/
public class TaxiBeingServerdOrdersFragment extends BaseTaxiUIFragment
implements View.OnClickListener, ICommonNaviChangedCallback {
public static final String TAG = "OCHTaxiBeingServerd";
private Activity mActivity;
private TaxiFragment mTaxiFragment;
private String mOrderNo;
private volatile int mTtsLessThan200Tip = 0;//离终点200米提示播报
private OrderQueryRespBean.Result mCurrentOrder = null;
private boolean isFirstStartAutopilotDone = true;
private TextView mOrderStatus;
private ImageView mOrderCancel;
private TextView mOrderServerStatus;
private ConstraintLayout mBeingOrderLayout;
private ConstraintLayout mContentModule3;
private ConstraintLayout mContentModule2;
private TextView mDistanceAndTime3;
private TextView mDistanceAndTime2;
private TextView mStationTv2;
private TextView mOrderOtherContent3;
private TextView mArrivedStartTimeTv32;
private TextView mTitleTV2;
private LinearLayout mContentModule31;
private TextView mStationTv31;
private ConstraintLayout mContentModule32;
private TextView mStationTv32;
private TextView mArrivedStationTitleTv32;
private TextView mGoAheadStationTitleTv31;
private TextView mCatchStationTitleTv31;
private ImageView mNaviStartIcon;
private ImageView mNaviToEndIcon;
private TextView mPassengerNum;
private TextView mPassengerPhone;
private ConstraintLayout mPassengerInfoLayout;
private TextView mNoDatasTv;
private ConstraintLayout mNoDataView;
private volatile int saveOrderState = -1;
private ItinerarySummaryDialog dialog;
public static TaxiBeingServerdOrdersFragment newInstance(Activity activity, TaxiFragment taxiFragment) {
Bundle args = new Bundle();
TaxiBeingServerdOrdersFragment fragment = new TaxiBeingServerdOrdersFragment();
fragment.setArguments(args);
fragment.mActivity = activity;
fragment.mTaxiFragment = taxiFragment;
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_being_order;
}
@Override
protected void initViews(View view) {
mOrderStatus = view.findViewById(R.id.module_och_taxi_order_status);
mOrderCancel = view.findViewById(R.id.module_och_taxi_order_cancel_iv);
mOrderServerStatus = view.findViewById(R.id.module_och_taxi_order_server_status_tv);
mBeingOrderLayout = view.findViewById(R.id.module_och_taxi_being_order_content);
mContentModule2 = view.findViewById(R.id.module_och_taxi_order_status_station_2);
mContentModule3 = view.findViewById(R.id.module_och_taxi_order_status_station_3);
mDistanceAndTime2 = view.findViewById(R.id.module_och_taxi_order_distance_anchor_2);
mContentModule31 = view.findViewById(R.id.module_och_taxi_order_go_ahead_station_31);
mContentModule32 = view.findViewById(R.id.module_och_taxi_order_arrive_station_32);
mStationTv2 = view.findViewById(R.id.module_och_taxi_order_station_2);
mStationTv31 = view.findViewById(R.id.module_och_taxi_order_start_station_31);
mStationTv32 = view.findViewById(R.id.module_och_taxi_order_end_station_32);
mOrderOtherContent3 = view.findViewById(R.id.module_och_taxi_order_other_content_3);
mDistanceAndTime3 = view.findViewById(R.id.module_och_taxi_order_distance_anchor_3);
mArrivedStartTimeTv32 = view.findViewById(R.id.module_och_taxi_order_had_arrived_time_32);
mTitleTV2 = view.findViewById(R.id.module_och_taxi_order_station_title_2);
mCatchStationTitleTv31 = view.findViewById(R.id.go_ahead_station_catch_31);
mGoAheadStationTitleTv31 = view.findViewById(R.id.go_ahead_station_31);
mArrivedStationTitleTv32 = view.findViewById(R.id.arrive_station_32);
mPassengerInfoLayout = view.findViewById(R.id.module_och_taxi_order_passenger_data);
mPassengerNum = view.findViewById(R.id.taxi_passenger_num);
mPassengerPhone = view.findViewById(R.id.taxi_passenger_phone);
mNoDatasTv = view.findViewById(R.id.no_order_data_tv);
mNoDataView = view.findViewById(R.id.being_no_data_view);
initOnClickListener();
initNaviView(view);
isHaveBeingOrder(false);
//任意模式下调试信息都打开
initOrderTestBar();
}
private void initOnClickListener() {
mOrderCancel.setOnClickListener(this);
mOrderServerStatus.setOnClickListener(this);
}
@Override
public void onResume() {
super.onResume();
}
private void initNaviView(View view) {
mNaviStartIcon = view.findViewById(R.id.module_och_taxi_navi_iv);
mNaviStartIcon.setOnClickListener(this);
mNaviToEndIcon = view.findViewById(R.id.module_och_taxi_navi_end_iv);
mNaviToEndIcon.setOnClickListener(this);
}
/**
* 初始化订单信息
*/
@RequiresApi(api = Build.VERSION_CODES.P)
public void updateCurrentOrderStatusChanged(OrderQueryRespBean.Result order) {
try {
if (order == null) return;
if (order.orderStatus == TaxiOrderStatusEnum.JourneyCompleted.getCode()) {
mCurrentOrder = null;
isHaveBeingOrder(false);
mDistanceAndTime2.setText("距离 - - 公里，用时 - - 分");
mDistanceAndTime3.setText("距离 - - 公里，用时 - - 分");
return;
}
mOrderNo = order.orderNo;
onOrderStatusChanged(order);
if (TaxiOrderStatusEnum.ArriveAtEnd.getCode() == order.orderStatus) {
showOrHideOrderModeBtn(false);
mTaxiFragment.queryCurOrderRouteInfo();
mContentModule3.setVisibility(View.GONE);
mContentModule2.setVisibility(View.VISIBLE);
CallerLogger.d(M_TAXI + TAG, "已经达到终点");
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_server_end),
Color.parseColor("#FFFFFF"),
Color.parseColor("#FF1D5EF3"),
true);
mTitleTV2.setText("送乘客至");
mStationTv2.setText(order.endSiteAddr);
} else if (TaxiOrderStatusEnum.OnTheWayToEnd.getCode() == order.orderStatus) {
CallerLogger.d(M_TAXI + TAG, "已经去往终点");
showOrHideOrderModeBtn(false);
mContentModule3.setVisibility(View.GONE);
mContentModule2.setVisibility(View.VISIBLE);
mOrderStatus.setText(R.string.module_och_taxi_on_the_way_2_end_station);
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_close),
Color.parseColor("#FFFFFF"),
Color.parseColor("#FF1D5EF3"),
true);
mTitleTV2.setText("送乘客至");
mStationTv2.setText(order.endSiteAddr);
} else if (TaxiOrderStatusEnum.UserArriveAtStart.getCode() == order.orderStatus
|| TaxiOrderStatusEnum.ArriveAtStart.getCode() == order.orderStatus){
mContentModule2.setVisibility(View.GONE);
mContentModule3.setVisibility(View.VISIBLE);
mArrivedStartTimeTv32.setVisibility(View.VISIBLE);
mContentModule32.setVisibility(View.VISIBLE);
mContentModule31.setVisibility(View.GONE);
mOrderOtherContent3.setVisibility(View.GONE);
Calendar currentCale = DateTimeUtils.getCurrentDateTime();
String currentHM = DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.HH_mm);
String currentDay = DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.yyyy_MM_dd);
String strHtml11 = "<font color=\"#CAD6FF\">已于</font><br>"
+ "<b><font color=\"#FFFFFF\"><big><big>" + currentHM + "</big></big></font></b>"
+ "<font color=\"#CAD6FF\">" + " " + "到达乘客上车地点</font>";
mArrivedStartTimeTv32.setLineHeight(60);
mArrivedStartTimeTv32.setText(Html.fromHtml(strHtml11));
mArrivedStationTitleTv32.setText("送乘客至");
mStationTv32.setText(order.endSiteAddr);
currentCale.add(Calendar.MINUTE, 10);
String strHtml13 = "";
if (currentDay.equals(DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.yyyy_MM_dd))) {
strHtml13 = "<font color=\"#CAD6FF\">免费等待至 </font>"
+ "<b><font color=\"#FFFFFF\"><big>" + DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.HH_mm) + "</big></b></font>";
} else {
strHtml13 = "<font color=\"#CAD6FF\">免费等待至</font>"
+ "<font color=\"#FFFFFF\"><big>" + DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.MM_dd_HH_mm) + "</big></font>";
}
mDistanceAndTime3.setText(Html.fromHtml(strHtml13));
if (TaxiOrderStatusEnum.ArriveAtStart.getCode() == order.orderStatus){
CallerLogger.d(M_TAXI + TAG, "车辆已经达到起点");
mPassengerInfoLayout.setVisibility(View.VISIBLE);
mPassengerNum.setText(order.passengerNum + "人");
mPassengerPhone.setText(order.passengerPhone);
mOrderStatus.setText(R.string.module_och_taxi_waiting);
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_server_start_wait_check),
Color.parseColor("#FFFFFF"),
Color.parseColor("#FF1D5EF3"),
true);
showOrHideOrderModeBtn(false);
}else if (TaxiOrderStatusEnum.UserArriveAtStart.getCode() == order.orderStatus ){
CallerLogger.d(M_TAXI + TAG, "乘客已上车验证成功");
mPassengerInfoLayout.setVisibility(View.GONE);
mOrderStatus.setText(R.string.module_och_taxi_user_check_success);
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_server_start),
Color.parseColor("#FFFFFF"),
Color.parseColor("#FF1D5EF3"),
true);
/** 2023.12.18 1.去除"自驾/安全"模式选择，默认自驾模式且无需点击；
* 2.server去除订单流转对"安全确认"的限制（读写接口默认反馈ok，但"开启自动驾驶成功"不再限制）
*/
// showOrHideOrderModeBtn(true);
showOrHideOrderModeBtn(false);
CallerLogger.d(M_TAXI + TAG, "自驾模式");
startOrEndService();
}
}else if (TaxiModel.getInstance().checkCurrentOCHOrder()) {
CallerLogger.d(M_TAXI + TAG, "前往乘客上车地点");
mContentModule2.setVisibility(View.GONE);
mContentModule3.setVisibility(View.VISIBLE);
mContentModule31.setVisibility(View.VISIBLE);
mArrivedStartTimeTv32.setVisibility(View.GONE);
mContentModule32.setVisibility(View.GONE);
mOrderOtherContent3.setVisibility(View.VISIBLE);
mDistanceAndTime3.setVisibility(View.VISIBLE);
mPassengerInfoLayout.setVisibility(View.VISIBLE);
mPassengerNum.setText(order.passengerNum + "人");
mPassengerPhone.setText(order.passengerPhone);
mOrderStatus.setText(R.string.module_och_taxi_new_order);
showOrHideOrderModeBtn(false);
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_server_start),
Color.parseColor("#4DFFFFFF"),
Color.parseColor("#4D1D5EF3"),
false);
mGoAheadStationTitleTv31.setText("前往");
mCatchStationTitleTv31.setText("接乘客");
mStationTv31.setText(order.startSiteAddr);
Calendar currentCale = DateTimeUtils.getCurrentDateTime();
Calendar startCale = DateTimeUtil.formatLongToCalendar(order.bookingTime);
String currentDay = DateTimeUtil.formatCalendarToString(currentCale, DateTimeUtil.yyyy_MM_dd);
String startDay = DateTimeUtil.formatCalendarToString(startCale, DateTimeUtil.yyyy_MM_dd);
String strHtml1 = "";
if (currentDay.equals(startDay)) {
strHtml1 = "<font color=\"#CAD6FF\">乘客将于</font><br>"
+ "<b><font color=\"#FFFFFF\"><big><big>" + DateTimeUtil.formatCalendarToString(startCale, DateTimeUtil.HH_mm) + "</big></big></font></b>"
+ "<font color=\"#CAD6FF\"> 用车</font>";
} else {
strHtml1 = "<font color=\"#CAD6FF\">乘客将于</font><br>"
+ "<b><font color=\"#FFFFFF\"><big><big>" + DateTimeUtil.formatCalendarToString(startCale, DateTimeUtil.MM_dd_HH_mm) + "</big></big></font></b>"
+ "<font color=\"#CAD6FF\"> 用车</font>";
}
mOrderOtherContent3.setText(Html.fromHtml(strHtml1));
}
}catch (NullPointerException e){ //可能会出现订单信息已经轮询回来，但进行中页面控件还未初始化完成的情况
TaxiModel.getInstance().clearCurrentOCHOrder();
}
}
private void showOrHideOrderModeBtn(boolean isShow) {
if (isShow){
mOrderServerStatus.setVisibility(View.GONE);
}else {
mOrderServerStatus.setVisibility(View.VISIBLE);
}
}
private void startNaviToStation(boolean isVoicePlay, double stationLat, double stationLng) {
AmapNaviToDestinationModel.getInstance(getContext()).destroyAmaNavi();
MogoLocation gcj02Location = OchLocationManager.getGCJ02Location();
double mCurLatitude = gcj02Location.getLatitude();
double mCurLongitude =gcj02Location.getLongitude();
CallerLogger.d(M_TAXI + TAG, "currentLatLng=" + mCurLatitude + " " +mCurLongitude);
NaviLatLng startNaviLatLng = new NaviLatLng(mCurLatitude, mCurLongitude);
NaviLatLng endNaviLatLng = new NaviLatLng(stationLat, stationLng);
AmapNaviToDestinationModel.getInstance(getContext()).initAMapNavi(startNaviLatLng, endNaviLatLng);
AmapNaviToDestinationModel.getInstance(getContext()).setVoiceIsMute(isVoicePlay);
AmapNaviToDestinationModel.getInstance(getContext()).setTaxiNaviChangedCallback(this);
}
private void showOrHideNavi(boolean isShow) {
if (!isShow) {
mNaviStartIcon.setVisibility(View.GONE);
mNaviToEndIcon.setVisibility(View.GONE);
AmapNaviToDestinationModel.getInstance(getContext()).destroyAmaNavi();
mTaxiFragment.showAmapNaviToStationFragment(false);
mTaxiFragment.showRottingToStationFragment(false);
}
}
/**
* 剩余里程和剩余时间
* @param meters m
* @param timeInSecond 秒
*/
public void updateDistanceAndTime(long meters, long timeInSecond) {
String dis = "0";
String disUnit = "公里";
if (meters > 0){
if (meters / 1000 < 1){
disUnit = "米";
dis = String.valueOf(Math.round(meters));
}else {
disUnit = "公里";
dis = NumberFormatUtil.formatLong((double)meters / 1000);
}
}
int min = (int)Math.ceil((double)timeInSecond/ 60f);
String strHtml2 = "<font color=\"#CAD6FF\">里程 </font>" + "<b><font color=\"#FFFFFF\">" + dis + "</font></b>" + "<font color=\"#CAD6FF\"> "+disUnit+"</font>"
+ "<font color=\"#CAD6FF\">，剩余 </font>" + "<b><font color=\"#FFFFFF\">" + min + "</font></b>" + "<font color=\"#CAD6FF\"> 分钟</font>";
try {
if (mCurrentOrder != null && mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToStart.getCode()) { //前往上车点
mDistanceAndTime3.setText(Html.fromHtml(strHtml2));
if (mNaviStartIcon.getVisibility() == View.GONE){
mNaviStartIcon.setVisibility(View.VISIBLE);
}
} else if (mCurrentOrder != null && mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.getCode()) { //前往终点 时间单位是分钟
if (mNaviToEndIcon.getVisibility() == View.GONE){
mNaviToEndIcon.setVisibility(View.VISIBLE);
}
if (mTtsLessThan200Tip < 1 && meters <= 250 && meters > 150){
speekVoice200mTipsOnce();
}
mDistanceAndTime2.setText(Html.fromHtml(strHtml2));
if (isFirstStartAutopilotDone){
isFirstStartAutopilotDone = false;
}
}
}catch (NullPointerException e){
}
}
private void speekVoice200mTipsOnce() {
mTtsLessThan200Tip = 1;
}
public void onCurrentOrderRouteInfoGot(OrderQueryRouteInfoRespBean.Result routeInfo) {// 单位 米， 秒
CallerLogger.d(M_TAXI + TAG, "durationToEnd = " + routeInfo.durationToEnd);
String dis = "0";
long distance = routeInfo.distanceToEnd;
long duration = routeInfo.durationToEnd;
if (routeInfo.distanceToEnd > 0){
dis = NumberFormatUtil.formatLong( (double) distance/ 1000);
}
dialog.setOrderMileage(distance);
String strHtml2 = "<font color=\"#CAD6FF\">全程 </font>" + "<b><font color=\"#FFFFFF\">" + dis + "</font></b>" + "<font color=\"#CAD6FF\"> 公里</font>"
+ "<font color=\"#CAD6FF\">，总用时 </font>" + "<b><font color=\"#FFFFFF\">" + (int)Math.ceil( (double) duration/ 60) + "</font></b>" + "<font color=\"#CAD6FF\"> 分钟</font>";
if (mContentModule2 != null && mContentModule2.getVisibility() == View.VISIBLE) {
mDistanceAndTime2.setText(Html.fromHtml(strHtml2));
} else if (mContentModule3 != null && mContentModule3.getVisibility() == View.VISIBLE) {
mDistanceAndTime3.setText(Html.fromHtml(strHtml2));
}
}
@Override
public void onDestroyView() {
super.onDestroyView();
mTaxiFragment = null;
mActivity = null;
AmapNaviToDestinationModel.getInstance(getContext()).destroyAmaNavi();
}
private void startOrEndService() {
if (mCurrentOrder == null) return;
if (TaxiOrderStatusEnum.ArriveAtStart.getCode() == mCurrentOrder.orderStatus){ //到达乘客上车点，司机可跳过乘客屏认证
mTaxiFragment.jumpPassengerCheckDone();
}else if (TaxiOrderStatusEnum.UserArriveAtStart.getCode() == mCurrentOrder.orderStatus) {//点击此按钮，说明通知后端准备好开启自动驾驶的条件
mTaxiFragment.confirmAutopilotConditionByDriver();
}else if (TaxiOrderStatusEnum.ArriveAtEnd.getCode() == mCurrentOrder.orderStatus) {//点击了完成服务，结束订单并更新订单信息
mTaxiFragment.completeOrderService();
//VoiceNotice.showNotice(ResourcesUtils.getString(R.string.module_och_taxi_order_server_completed_tip));
}else if (TaxiOrderStatusEnum.OnTheWayToEnd.getCode() == mCurrentOrder.orderStatus){//前往目的地过程中可提前结束行程
//自驾中提示，接管后才能结束
if (CallerAutoPilotStatusListenerManager.INSTANCE.getState()
== IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING){
ToastUtils.showLong(R.string.taxi_switch_line_btn_warning1);
}else {
closeOrderDialog();
}
}
}
private void closeOrderDialog() {
OCHCommitDialog.Builder builder = new OCHCommitDialog.Builder();
OCHCommitDialog closeOrderDialog = builder
.title(getString(R.string.dialog_order_close_title))
.tips(getString(R.string.dialog_order_close_content))
.confirmStr(getString(R.string.dialog_order_close_confirm))
.cancelStr(getString(R.string.dialog_order_close_cancel))
.build(getContext());
closeOrderDialog.setClickListener(new OCHCommitDialog.ClickListener() {
@Override
public void confirm() {
if (mTaxiFragment != null) mTaxiFragment.closeOrderByMan();
}
@Override
public void cancel() {
closeOrderDialog.dismiss();
}
});
closeOrderDialog.show();
}
public void onOrderStatusChanged(OrderQueryRespBean.Result order) {
int status = order.orderStatus;
CallerLogger.d(M_TAXI + TAG, "status==" + status);
mCurrentOrder = order;
mActivity.runOnUiThread(() -> {
if (status == TaxiOrderStatusEnum.None.getCode() || status == TaxiOrderStatusEnum.Cancel.getCode() || status == TaxiOrderStatusEnum.JourneyCompleted.getCode()) {
isHaveBeingOrder(false);
mCurrentOrder = null;
clearOrderTag();
} else {
isHaveBeingOrder(true);
}
if (status != saveOrderState) {
TaxiOrderStatusEnum ochStatus = TaxiOrderStatusEnum.valueOf(status);
switch (ochStatus) {
case OnTheWayToStart:
if(dialog!=null&&dialog.isShowing()) {
dialog.dismiss();
}
dialog = null;
mOrderCancel.setVisibility(View.VISIBLE);
VoiceNotice.showNotice(mActivity.getString(R.string.module_och_taxi_new_order));
mTtsLessThan200Tip = 0;
isFirstStartAutopilotDone = true;
double orderStartStationLat = order.startSiteGcjPoint.get(1);
double orderStartStationLng = order.startSiteGcjPoint.get(0);
startNaviToStation(false, orderStartStationLat, orderStartStationLng);
setOrRemoveMapMaker(true, TaxiConst.TAXI_START_MAP_MAKER,order.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(true, TaxiConst.TAXI_END_MAP_MAKER,order.endSitePoint,R.raw.end_marker);
break;
case Cancel:
if(dialog!=null&&dialog.isShowing()) {
dialog.dismiss();
}
dialog = null;
mCurrentOrder = null;
mTtsLessThan200Tip = 0;
isFirstStartAutopilotDone = true;
mOrderCancel.setVisibility(View.VISIBLE);
//VoiceNotice.showNotice(mActivity.getString(R.string.module_och_taxi_order_cancel));
showOrHideNavi(false);
setOrRemoveMapMaker(false, TaxiConst.TAXI_START_MAP_MAKER,order.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(false, TaxiConst.TAXI_END_MAP_MAKER,order.endSitePoint,R.raw.end_marker);
break;
case ArriveAtStart:
case UserArriveAtStart:
if(dialog!=null&&dialog.isShowing()) {
dialog.dismiss();
}
dialog = null;
mTtsLessThan200Tip = 0;
isFirstStartAutopilotDone = true;
mOrderCancel.setVisibility(View.VISIBLE);
if (TaxiOrderStatusEnum.UserArriveAtStart.getCode() == ochStatus.getCode()){
//VoiceNotice.showNotice(mActivity.getString(R.string.module_och_taxi_order_status_ph_text_check_success));
}else {
VoiceNotice.showNotice(mActivity.getString(R.string.module_och_taxi_order_status_ph_text));
}
showOrHideNavi(false);
setOrRemoveMapMaker(true, TaxiConst.TAXI_START_MAP_MAKER,order.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(true, TaxiConst.TAXI_END_MAP_MAKER,order.endSitePoint,R.raw.end_marker);
break;
case OnTheWayToEnd:
if(dialog!=null&&dialog.isShowing()) {
dialog.dismiss();
}
dialog = null;
mOrderCancel.setVisibility(View.VISIBLE);
if (mTaxiFragment != null) {
showNaviToEndStationFragment(false);
}
setOrRemoveMapMaker(false, TaxiConst.TAXI_START_MAP_MAKER,order.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(true, TaxiConst.TAXI_END_MAP_MAKER,order.endSitePoint,R.raw.end_marker);
break;
case ArriveAtEnd:
if(dialog==null){
dialog = new ItinerarySummaryDialog(getContext(),true,R.style.summary_dialog);
}
if(!dialog.isShowing()) {
dialog.show();
}
mTtsLessThan200Tip = 0;
mOrderCancel.setVisibility(View.GONE);
//VoiceNotice.showNotice(mActivity.getString(R.string.module_och_taxi_order_auto_arrive_end_tip));
showOrHideNavi(false);
setOrRemoveMapMaker(false, TaxiConst.TAXI_START_MAP_MAKER,order.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(false, TaxiConst.TAXI_END_MAP_MAKER,order.endSitePoint,R.raw.end_marker);
break;
case JourneyCompleted:
if(dialog!=null&&dialog.isShowing()) {
dialog.dismiss();
}
dialog = null;
mCurrentOrder = null;
mTtsLessThan200Tip = 0;
isFirstStartAutopilotDone = true;
mOrderCancel.setVisibility(View.GONE);
VoiceNotice.showNotice("感谢您使用"+ SkinResources.getInstance().getString(R.string.operation_platform_name)+"智行,再见~");
showOrHideNavi(false);
break;
}
}
saveOrderState = status;
});
}
private void clearOrderTag() {
saveOrderState = -1;
mDistanceAndTime2.setText("距离 - - 公里，用时 - - 分");
mDistanceAndTime3.setText("距离 - - 公里，用时 - - 分");
}
/**
* 是否有正在进行的订单，进行UI显示
*
* @param being
*/
public void isHaveBeingOrder(boolean being) {
CallerLogger.d(M_TAXI + TAG, "isHaveBeingOrder = " + being);
try {
if (being) {
mNoDataView.setVisibility(View.GONE);
mBeingOrderLayout.setVisibility(View.VISIBLE);
} else {
mNoDataView.setVisibility(View.VISIBLE);
mNoDatasTv.setText("暂无进行中订单");
mBeingOrderLayout.setVisibility(View.GONE);
}
}catch (NullPointerException e){ //可能会出现订单信息已经轮询回来，但进行中页面控件还未初始化完成的情况
TaxiModel.getInstance().clearCurrentOCHOrder();
}
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.module_och_taxi_order_server_status_tv) {
CallerLogger.d(M_TAXI + TAG, mOrderServerStatus.getText().toString());
startOrEndService();
} else if (v.getId() == R.id.module_och_taxi_order_cancel_iv) {
new TaxiOrderCancelDialog(mTaxiFragment, mActivity, mOrderNo, saveOrderState).show();
} else if (v.getId() == R.id.module_och_taxi_navi_iv) {
if (mTaxiFragment != null) {
showNaviToStartStationFragment(true);
}
} else if (v.getId() == R.id.module_och_taxi_navi_end_iv){
// TODO: 2021/11/30 打开去往乘客下车点的导航页面
if (mTaxiFragment != null) {
showNaviToEndStationFragment(true);
}
}
}
/**
* 显示/隐藏 前往乘客上车点的导航
*
* @param isShow
*/
private void showNaviToStartStationFragment(boolean isShow) {
if (mCurrentOrder != null &&
mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToStart.getCode()){
double orderStartStationLat = mCurrentOrder.startSiteGcjPoint.get(1);
double orderStartStationLng = mCurrentOrder.startSiteGcjPoint.get(0);
mTaxiFragment.showAmapNaviToStationFragment(isShow);
startNaviToStation(isShow, orderStartStationLat, orderStartStationLng);
}
}
/**
* 显示/隐藏 前往乘客目的地的导航
*
* @param isShow
*/
private void showNaviToEndStationFragment(boolean isShow) {
mTaxiFragment.startNaviToEndStation(isShow);
}
public void onCurrentOrderCancelDone() {
//去除起终点
if (mCurrentOrder != null){
setOrRemoveMapMaker(false, TaxiConst.TAXI_START_MAP_MAKER,mCurrentOrder.startSitePoint,R.raw.star_marker);
setOrRemoveMapMaker(false, TaxiConst.TAXI_END_MAP_MAKER,mCurrentOrder.endSitePoint,R.raw.end_marker);
}
//提交取消订单后的回调
ToastUtils.showShort("订单取消成功");
//更新界面
isHaveBeingOrder(false);
showOrHideNavi(false);
clearOrderTag();
}
/**
* 订单流转debug START
*/
private void initOrderTestBar() {
mOrderStatus.setOnLongClickListener(v -> {
mTaxiFragment.clickTestBar();
return false;
});
}
@Override
public void onCurrentNaviDistAndTimeChanged(int meters, long timeInSecond) {
updateDistanceAndTime(meters, timeInSecond);
if (mCurrentOrder != null
&& mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.getCode()){
mTaxiFragment.reportToEndDisAndTime(meters, timeInSecond);
}
}
@Override
public void reInitNaviAmap(boolean isPlay, boolean isRestart) {
CallerLogger.d(M_TAXI + TAG, "isPlay = " + isPlay + ", isRestart=" + isRestart);
if (!isRestart) {
mTaxiFragment.showAmapNaviToStationFragment(false);
return;
}
UiThreadHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (mCurrentOrder != null &&
mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToStart.getCode()) {
double orderStartStationLat = mCurrentOrder.startSiteGcjPoint.get(1);
double orderStartStationLng = mCurrentOrder.startSiteGcjPoint.get(0);
startNaviToStation(false, orderStartStationLat, orderStartStationLng);
}
}
}, 2000);
UiThreadHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (mCurrentOrder != null &&
mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToStart.getCode()) {
if (mNaviStartIcon.getVisibility() == View.GONE) {
mNaviStartIcon.setVisibility(View.VISIBLE);
}
}
if (mCurrentOrder != null &&
mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.getCode()){
if (mNaviToEndIcon.getVisibility() == View.GONE) {
mNaviToEndIcon.setVisibility(View.VISIBLE);
}
}
}
}, 3000);
}
public void onNaviToEndAmap(boolean isShow) {
if (mCurrentOrder != null &&
mCurrentOrder.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.getCode()){
double orderEndStationLat = mCurrentOrder.endSiteGcjPoint.get(1);
double orderEndStationLng = mCurrentOrder.endSiteGcjPoint.get(0);
mTaxiFragment.showAmapNaviToStationFragment(isShow);
startNaviToStation(isShow,orderEndStationLat,orderEndStationLng);
}
}
/**
* 绘制地图起点终点
* @param isAdd
* @param uuid
* @param station
*/
private void setOrRemoveMapMaker(boolean isAdd, String uuid, List<Double> station,int resourceId){
if (isAdd){
//开启线程执行起终点marker设置
Runnable setMapMarkerRunnable = () -> {
CallerLogger.d(M_TAXI + "setMapMaker= " + Thread.currentThread().getName(),
uuid + "=latitude=" + station.get(1) + ",longitude=" + station.get(0));
Point.Options.Builder builder = new Point.Options.Builder(TaxiConst.TYPE_MARKER_TAXI_ORDER, Level.MAP_MARKER)
.setId(uuid)
.anchor(0.5f, 0.5f)
.set3DMode(true)
.isUseGps(true)
.controlAngle(false)
.icon3DRes(resourceId)
.latitude(station.get(1))
.longitude(station.get(0));
IMoGoOverlayManager overlayManager = CallerMapUIServiceManager.INSTANCE.getOverlayManager();
if (overlayManager != null) {
overlayManager.showOrUpdatePoint(builder.build(),DEFAULT);
}
};
OCHThreadPoolManager.getsInstance().execute(setMapMarkerRunnable);
}else {
//开启线程移除起终点marker设置
Runnable removeMapMarkerRunnable = () -> {
CallerLogger.d(M_TAXI + "RemoveMapMaker=" + Thread.currentThread().getName(),
uuid + "=latitude=" + station.get(1) + ",longitude=" + station.get(0));
// Objects.requireNonNull(CallerMapUIServiceManager.INSTANCE.getMarkerManager(AbsMogoApplication.getApp())).removeMarkers(uuid);
IMoGoOverlayManager overlayManager = CallerMapUIServiceManager.INSTANCE.getOverlayManager();
if (overlayManager != null) {
overlayManager.removePoint(uuid);
}
};
OCHThreadPoolManager.getsInstance().execute(removeMapMarkerRunnable);
}
}
public void updateOrderBottomBtnUI() {
try {
ToastUtils.showLong(ResourcesUtils.getString(
R.string.module_och_taxi_order_choose_start_autopilot_tip));
showOrHideOrderModeBtn(false);
updateOrderBottomBtn(getString(R.string.module_och_taxi_order_server_wait_passenger_start),
Color.parseColor("#4DFFFFFF"),
Color.parseColor("#FF1D5EF3"),
false);
}catch (NullPointerException e){
mTaxiFragment.confirmAutopilotConditionByDriver();
}
}
public void updateOrderBottomBtn(String txt, int txtColorId, int bgColorId,boolean isClickable){
mOrderServerStatus.setText(txt);
mOrderServerStatus.setTextColor(txtColorId);
GradientDrawable background = (GradientDrawable) mOrderServerStatus.getBackground();//GradientDrawable是Drawable的子类
background.setColor(bgColorId);
mOrderServerStatus.setClickable(isClickable);
}
}

401
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiFragment.java
View File

@@ -1,401 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.fragment.app.FragmentTransaction;
import com.mogo.eagle.core.data.temp.EventLogout;
import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.overlay.IMoGoOverlayManager;
import com.mogo.och.common.module.biz.login.LoginStatusManager;
import com.mogo.och.common.module.biz.login.OpenOrderStatusEnum;
import com.mogo.och.taxi.R;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import com.mogo.och.taxi.model.TaxiModel;
import com.mogo.och.taxi.presenter.TaxiPresenter;
import com.mogo.och.taxi.utils.TPRouteDataTestUtils;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;
import java.lang.ref.WeakReference;
import java.util.List;
/**
* @author congtaowang
* @since 2021/1/18
*
* 网约车-出租车UI
*/
public class TaxiFragment extends BaseTaxiTabFragment<TaxiFragment, TaxiPresenter> implements ITaxiView {
public static final String TAG = "TaxiFragment";
public static TaxiFragment newInstance() {
Bundle args = new Bundle();
TaxiFragment fragment = new TaxiFragment();
fragment.setArguments(args);
return fragment;
}
// 抢单信息
private WeakReference<TaxiGrabOrderFragment> grabOrderFragmentWR;
// 待服务信息
private WeakReference<TaxiServerOrdersFragment> serverOrdersFragmentWR;
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
}
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
EventBus.getDefault().register(this);
return super.onCreateView(inflater, container, savedInstanceState);
}
// @Override
// public int getStationPanelViewId() {
// return R.layout.taxi_panel;
// }
//
// @Override
// public void startAutopilot() {
// // 在自动驾驶中，或者自己确认车辆环境可开启自动驾驶 则可点击
// if ((mPresenter.getCurOrderStatus() == TaxiOrderStatusEnum.OnTheWayToEnd ||
// mPresenter.getCurOrderStatus() == TaxiOrderStatusEnum.UserArriveAtStart)
// && !isStarting) {
// CallerLogger.d(M_TAXI + TAG, "startAutopilot");
// mPresenter.startAutoPilot();
// }
// }
@Override
public void startNaviToEndStation(boolean isShow) {
mPresenter.startNaviToEndStation(isShow);
}
@Override
public String getTagName() {
return "TaxiFragment";
}
@Override
protected void initViews() {
super.initViews();
initFragment();
initOrderTestBar();
}
private void initFragment() {
// serverOrdersFragmentWR = new WeakReference<>(TaxiServerOrdersFragment.newInstance());
//// grabOrderFragmentWR = new WeakReference<>(TaxiGrabOrderFragment.newInstance());
// FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
// //默认显示OCHTaxiServerOrdersFragment
// transaction.add(R.id.fragment_container, serverOrdersFragmentWR.get()).show(serverOrdersFragmentWR.get());
// transaction.add(R.id.fragment_container, grabOrderFragmentWR.get()).hide(grabOrderFragmentWR.get());
// transaction.commitAllowingStateLoss();
}
private void showGrabFragmentAndUpdate() {
// FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
// if (grabOrderFragmentWR == null || grabOrderFragmentWR.get() == null) {
// grabOrderFragmentWR = new WeakReference<>(TaxiGrabOrderFragment.newInstance());
// transaction.add(R.id.fragment_container, grabOrderFragmentWR.get())
// .show(grabOrderFragmentWR.get()).commitAllowingStateLoss();
// } else {
// transaction.show(grabOrderFragmentWR.get()).hide(serverOrdersFragmentWR.get()).commitAllowingStateLoss();
// }
}
public void showServerFragmentAndUpdate() {
// FragmentTransaction transaction = getChildFragmentManager().beginTransaction();
// if (serverOrdersFragmentWR == null || serverOrdersFragmentWR.get() == null) {
// serverOrdersFragmentWR = new WeakReference<>(TaxiServerOrdersFragment.newInstance());
// transaction.add(R.id.fragment_container, serverOrdersFragmentWR.get())
// .show(serverOrdersFragmentWR.get());
// } else {
// transaction.show(serverOrdersFragmentWR.get()).hide(grabOrderFragmentWR.get()).commitAllowingStateLoss();
// }
}
@NonNull
@Override
protected TaxiPresenter createPresenter() {
return new TaxiPresenter(this);
}
@Override
protected void onChangeOperationStatus() {
mPresenter.updateCarStatus();
}
@Override
public void onDestroyView() {
EventBus.getDefault().unregister(this);
if (mPresenter != null) {
mPresenter.onDestroy(this);
}
super.onDestroyView();
}
public void updateAutopilotStatus(int status,boolean canStart) {
onAutopilotStatusChanged(status,canStart);
}
@RequiresApi(api = Build.VERSION_CODES.P)
public void updateCurrentOrderStatusChanged(OrderQueryRespBean.Result order) {
// if (serverOrdersFragmentWR != null && serverOrdersFragmentWR.get() != null) {
// serverOrdersFragmentWR.get().updateCurrentOrderStatusChanged(order);
// }
updateTaxiTestBarInfo(); //更新调试bar中信息
}
public void confirmAutopilotConditionByDriver(){
mPresenter.confirmAutopilotConditionByDriver();
}
public void jumpPassengerCheckDone(){
mPresenter.jumpPassengerCheckDone();
}
public void completeOrderService() {
mPresenter.completeOrderService();
}
public void startManualDirve(){
mPresenter.startManualDrive();
}
public void cancelCurOrder(int reasonType, String reaso) {
mPresenter.cancelCurOrder(reasonType, reaso);
}
public void cancelOrderById(String orderNo, int reasonType, String reason) {
mPresenter.cancelOrderById(orderNo, reasonType, reason);
}
public void onCurrentOrderCancelDone(){
startOrStopLoadingAnim(false);
/** 2023.12.18 1.去除"自驾/安全"模式选择，默认自驾模式且无需点击；
* 2.server去除订单流转对"安全确认"的限制（读写接口默认反馈ok，但"开启自动驾驶成功"不再限制）
*/
updateCtvAutopilotStatusTag(false);
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onCurrentOrderCancelDone();
}
public void onOrderCancelDone(String orderNo) {
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onOrderCancelDone(orderNo);
}
@Override
protected void updateOrderBottomBtnUI() {
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().updateOrderBottomBtnUI();
}
public void onNewBookingOrderGot(OrderQueryRespBean.Result order) {
if (null == order) return;
showGrabFragmentAndUpdate();
grabOrderFragmentWR.get().updateGrabOrder(order);
}
public void grabOrder() {
mPresenter.grabOrder();
}
public void cancelNewBookingOrder() {
mPresenter.cancelNewBookingOrder();
showServerFragmentAndUpdate();
}
public void onGrabOrderExecuteDone() {
if (null == grabOrderFragmentWR || grabOrderFragmentWR.get() == null) return;
grabOrderFragmentWR.get().onGrabOrderExecuteDone();
}
public void onGrabOrderSuccess(OrderQueryRespBean.Result order) {
if (null == grabOrderFragmentWR || grabOrderFragmentWR.get() == null) return;
if (null == order) {
showServerFragmentAndUpdate();
return;
}
showGrabFragmentAndUpdate();
grabOrderFragmentWR.get().onGrabOrderSuccess();
}
public void onGrabOrderFailed(OrderQueryRespBean.Result order) {
if (order == null) {
showServerFragmentAndUpdate();
return;
}
if (null == grabOrderFragmentWR || grabOrderFragmentWR.get() == null) return;
showGrabFragmentAndUpdate();
grabOrderFragmentWR.get().onGrabOrderFailed();
}
public void onNaviToEnd(boolean isAmap , boolean isShow){
if (isAmap){
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onNaviToEndAmap(isShow);
}else if (isShow){ //使用rotting数据
showRottingToStationFragment(true);
}else {
showAmapNaviToStationFragment(false);
}
}
public void closeOrderByMan(){
mPresenter.closeOrderByMan();
}
/**
* 高德计算出来的到达目的地的剩余里程和时间
* @param meters
* @param timeInSecond
*/
public void reportToEndDisAndTime(int meters, long timeInSecond){ //米/秒
mPresenter.reportToEndDisAndTime(Long.parseLong(String.valueOf(meters)),timeInSecond);
}
public void onOrdersWaitServiceChanged(List<OrderQueryRespBean.Result> waitServiceList) {
if (null == waitServiceList) return;
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onOrdersWaitServiceChanged(waitServiceList);
}
public void queryCurOrderRouteInfo() {
mPresenter.queryCurOrderRouteInfo();
}
public void onCurrentOrderRouteInfoGot(OrderQueryRouteInfoRespBean.Result routeInfo) {
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onCurrentOrderRouteInfoGot(routeInfo);
}
public void onCurrentOrderDistToEndChanged(long meters, long timeInSecond) {
if (null == serverOrdersFragmentWR || serverOrdersFragmentWR.get() == null) return;
serverOrdersFragmentWR.get().onCurrentOrderDistToEndChanged(meters, timeInSecond);
}
/**
* 订单流转debug START
*/
public void initOrderTestBar() {
// findViewById(R.id.test_bar_to_start).setOnClickListener(v -> {
// TaxiModel.getInstance().setArriveAtStartStation();
// });
// findViewById(R.id.test_bar_to_end).setOnClickListener(v -> {
// TaxiModel.getInstance().setArriveAtEndStation();
// });
// findViewById(R.id.test_bar_start_service_confirm).setOnClickListener(v -> {
// TaxiModel.getInstance().setDriverConfirmCondition();
// });
// findViewById(R.id.test_bar_on_the_way_to_end).setOnClickListener(v -> {
// if (!isStarting){
// mPresenter.startAutoPilot();
// }
// TaxiModel.getInstance().setOnTheWayToEndStation();
// });
// findViewById(R.id.test_bar_route).setOnClickListener(v -> {
// testRouteInfoUpload();
// });
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void changeOverview(EventLogout eventLogout){
if (eventLogout.getMessgae() == EventLogout.LOGOUT_TYPE){
CallerLogger.d(M_TAXI + TAG,"changeOverview Event消息去登出");
mPresenter.logout();
}
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void openOperationalInfoView(EventLogout eventLogout){
// if (eventLogout.getMessgae() == EventLogout.PERSONAL_TYPE){
// CallerLogger.d(M_TAXI + TAG,"openOperationalInfoView Event个人中心");
// openOperationalInfoView();
// }
}
private void testRouteInfoUpload() {
TPRouteDataTestUtils.converToRouteData();
}
//region Taxi调试信息：订单、线路、轨迹等信息
private View testBar;
private TextView testCurOrderId;
private TextView testCurLineId;
private TextView testCurLineName;
private TextView testCurTrajMd5;
private TextView testCurStopMd5;
private TextView testCurTrajMd5DPQP;
private TextView testCurStopMd5DPQP;
public void clickTestBar() {
if (testBar == null) {
testBar = findViewById(R.id.module_och_taxi_order_status_change_test_bar);
testCurOrderId = findViewById(R.id.test_bar_current_order_id);
testCurLineId = findViewById(R.id.test_bar_current_line_id);
testCurLineName = findViewById(R.id.test_bar_current_line_name);
testCurTrajMd5 = findViewById(R.id.test_bar_current_traj_md5);
testCurStopMd5 = findViewById(R.id.test_bar_current_stop_md5);
testCurTrajMd5DPQP = findViewById(R.id.test_bar_current_traj_md5_dpqp);
testCurStopMd5DPQP = findViewById(R.id.test_bar_current_stop_md5_dpqp);
}
if (testBar.getVisibility() == View.VISIBLE) {
testBar.setVisibility(View.GONE);
} else {
OrderQueryRespBean.Result order = TaxiModel.getInstance().getCurrentOCHOrder();
testCurOrderId.setText("orderNo:" + (order == null ? "" : String.valueOf(order.orderNo)));
testCurLineId.setText("lineId:" + (order == null ? "" : String.valueOf(order.lineId)));
testCurLineName.setText("lineName:" + (order == null ? "" : order.lineName));
testCurTrajMd5.setText("TMd5:" + (order == null ? "" : order.csvFileMd5));
testCurStopMd5.setText("SMd5:" + (order == null ? "" : order.txtFileMd5));
testCurTrajMd5DPQP.setText("TMd5DPQP:" + (order == null ? "" : order.csvFileMd5DPQP));
testCurStopMd5DPQP.setText("SMd5DPQP:" + (order == null ? "" : order.txtFileMd5DPQP));
testBar.setVisibility(View.VISIBLE);
}
}
private void updateTaxiTestBarInfo() {
if (testBar != null && testBar.getVisibility() == View.VISIBLE) {
OrderQueryRespBean.Result order = TaxiModel.getInstance().getCurrentOCHOrder();
testCurOrderId.setText("orderNo:" + (order == null ? "" : String.valueOf(order.orderNo)));
testCurLineId.setText("lineId:" + (order == null ? "" : String.valueOf(order.lineId)));
testCurLineName.setText("lineName:" + (order == null ? "" : order.lineName));
testCurTrajMd5.setText("TMd5:" + (order == null ? "" : order.csvFileMd5));
testCurStopMd5.setText("SMd5:" + (order == null ? "" : order.txtFileMd5));
testCurTrajMd5DPQP.setText("TMd5DPQP:" + (order == null ? "" : order.csvFileMd5DPQP));
testCurStopMd5DPQP.setText("SMd5DPQP:" + (order == null ? "" : order.txtFileMd5DPQP));
}
}
//endregion
}

193
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiGrabOrderFragment.java
View File

@@ -1,193 +0,0 @@
package com.mogo.och.taxi.ui;
import android.graphics.Color;
import android.graphics.drawable.AnimationDrawable;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.constraintlayout.widget.ConstraintLayout;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.och.common.module.utils.DateTimeUtil;
import com.mogo.och.common.module.voice.VoiceNotice;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import java.util.Calendar;
/**
* @author: wangmingjun
* @date: 2021/9/9
*/
public class TaxiGrabOrderFragment extends BaseTaxiUIFragment implements View.OnClickListener {
private TextView mOrderReserverTime;
private TextView mOrderGrabBt;
private TextView mOrderStartStation;
private TextView mOrderEndStation;
private TextView mOrderStartTitle;
private TextView mOrderEndTitle;
private ImageView mOrderCancelIv;
private ImageView mGrabResultAnimView;
private AnimationDrawable mGrabSuccessAnim;
private AnimationDrawable mGrabFailureAnim;
private CountDownTimer countDownTimer = null;
public static TaxiGrabOrderFragment newInstance() {
Bundle args = new Bundle();
TaxiGrabOrderFragment fragment = new TaxiGrabOrderFragment();
fragment.setArguments(args);
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_order_grab_view;
}
@Override
protected void initViews(View view) {
mOrderReserverTime = view.findViewById(R.id.grab_order_reserver_time);
mOrderCancelIv = view.findViewById(R.id.grab_order_cancel_iv);
mOrderGrabBt = view.findViewById(R.id.grab_order_tv);
mOrderStartStation = view.findViewById(R.id.grab_order_start_station);
mOrderEndStation = view.findViewById(R.id.grab_order_end_station);
mOrderEndTitle = view.findViewById(R.id.grab_order_end_station_title);
mOrderStartTitle = view.findViewById(R.id.grab_order_start_station_title);
mGrabResultAnimView = view.findViewById(R.id.grab_result_anim);
mGrabResultAnimView.setVisibility(View.GONE);
mOrderEndTitle.setVisibility(View.VISIBLE);
mOrderStartTitle.setVisibility(View.VISIBLE);
mOrderCancelIv.setOnClickListener(this);
mOrderGrabBt.setOnClickListener(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.grab_order_cancel_iv){//关闭抢单,如果是在抢单中，则只关闭界面，还继续抢单
if (mOrderGrabBt.getText().toString().equals("抢单中...")){
getOchTaxiFragment().showServerFragmentAndUpdate();
return;
}
if (null != countDownTimer){
countDownTimer.cancel();
}
VoiceNotice.stopCurrentTts();//中断当前在播语音
getOchTaxiFragment().cancelNewBookingOrder();
}else if (v.getId() == R.id.grab_order_tv){
if (!mOrderGrabBt.getText().toString().equals("抢单中...")){
getOchTaxiFragment().grabOrder();
}
}
}
private TaxiFragment getOchTaxiFragment(){
return (TaxiFragment)getParentFragment();
}
public void updateGrabOrder(OrderQueryRespBean.Result order){
mGrabResultAnimView.setVisibility(View.GONE);
Calendar calendar = DateTimeUtil.formatLongToCalendar(order.bookingTime);
if (DateTimeUtil.compareDateIsCurrentDay(calendar)){
mOrderReserverTime.setText("用车时间：今天 "+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.HH_mm));
// VoiceNotice.showNotice("预约单，今天"+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.HH_mm)+"从"
// +order.startSiteAddr+"到"+order.endSiteAddr);
}else {
mOrderReserverTime.setText("用车时间："+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.MM_dd_HH_mm));
// VoiceNotice.showNotice("预约单，"+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.MM_dd)+"从"
// +order.startSiteAddr+"到"+order.endSiteAddr);
}
mOrderStartStation.setText(order.startSiteAddr);
mOrderEndStation.setText(order.endSiteAddr);
mOrderGrabBt.setClickable(true);
mOrderGrabBt.setTextColor(Color.parseColor("#FFFFFF"));
ConstraintLayout.LayoutParams lp = (ConstraintLayout.LayoutParams)mOrderGrabBt.getLayoutParams();
lp.bottomMargin = 3;
mOrderGrabBt.setLayoutParams(lp);
mOrderGrabBt.setBackgroundResource(R.drawable.shape_size_grab_order_bt);
mOrderGrabBt.setText("抢单(10S)"); //开始倒计时任务
countDownTimer = new CountDownTimer(11000,1000){
@Override
public void onTick(long millisUntilFinished) {
mOrderGrabBt.setText("抢单"+"("+millisUntilFinished/1000+")");
}
@Override
public void onFinish() {//结束倒计时，不抢单
cancel();
getOchTaxiFragment().cancelNewBookingOrder();
}
}.start();
}
public void onGrabOrderExecuteDone(){//进入抢单状态，btn样式改变，并不可点击
if (null != countDownTimer){
countDownTimer.cancel();
}
mOrderGrabBt.setText("抢单中...");
ConstraintLayout.LayoutParams lp = (ConstraintLayout.LayoutParams)mOrderGrabBt.getLayoutParams();
lp.bottomMargin = 40;
mOrderGrabBt.setLayoutParams(lp);
mOrderGrabBt.setTextColor(Color.parseColor("#181D6D"));
mOrderGrabBt.setBackground(getResources().getDrawable(R.drawable.taxi_grabing_order_btn_bg));
mOrderGrabBt.setClickable(false);
}
// 接单成功，语音播报“抢单成功，请合理安排后续行程接送乘客”
// 接单未成功，语音播报“接单失败，请继续接单”
public void onGrabOrderSuccess(){//抢单成功，更新btn 和 动画 语音
VoiceNotice.showNotice("抢单成功，请合理安排后续行程接送乘客");
mGrabResultAnimView.setVisibility(View.VISIBLE);
mGrabResultAnimView.setImageDrawable(getResources().getDrawable(R.drawable.grab_success_anmi_flow));
mOrderGrabBt.setClickable(false);
mOrderGrabBt.setText("抢单成功！");
mGrabSuccessAnim = (AnimationDrawable)mGrabResultAnimView.getDrawable();
if (mGrabSuccessAnim.isOneShot()){
return;
}
mGrabSuccessAnim.start();
//开启动画结束的监听
long delayMillis = (long) mGrabSuccessAnim.getDuration(0) * mGrabSuccessAnim.getNumberOfFrames();
UiThreadHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (null != mGrabSuccessAnim && mGrabSuccessAnim.isRunning()){
mGrabSuccessAnim.stop();
}
// if (mGrabSuccessAnim.getFrame(mGrabSuccessAnim.getNumberOfFrames()-1) == mGrabSuccessAnim.getCurrent()){
getOchTaxiFragment().showServerFragmentAndUpdate();
// }
}
},delayMillis);
//开启动画结束的监听
}
public void onGrabOrderFailed(){//抢单失败，更新btn 和 动画 语音
VoiceNotice.showNotice("接单失败，请继续接单");
mGrabResultAnimView.setVisibility(View.VISIBLE);
mGrabResultAnimView.setImageDrawable(getResources().getDrawable(R.drawable.grab_failure_anmi_flow));
mOrderGrabBt.setClickable(false);
mOrderGrabBt.setText("抢单失败！");
mGrabFailureAnim = (AnimationDrawable)mGrabResultAnimView.getDrawable();
mGrabFailureAnim.start();
//开启动画结束的监听
long delayMillis = (long) mGrabFailureAnim.getDuration(0) * mGrabFailureAnim.getNumberOfFrames();
UiThreadHandler.postDelayed(new Runnable() {
@Override
public void run() {
if (null != mGrabFailureAnim && mGrabFailureAnim.isRunning()){
mGrabFailureAnim.stop();
}
getOchTaxiFragment().showServerFragmentAndUpdate();
}
},delayMillis);
}
@Override
public void onDestroy() {
super.onDestroy();
if (countDownTimer != null) countDownTimer.cancel();
}
}

290
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiMapDirectionView.kt
View File

@@ -1,290 +0,0 @@
package com.mogo.och.taxi.ui
import android.content.Context
import android.os.Bundle
import android.util.AttributeSet
import android.view.LayoutInflater
import android.view.MotionEvent
import android.widget.RelativeLayout
import com.amap.api.maps.AMap
import com.amap.api.maps.CameraUpdateFactory
import com.amap.api.maps.TextureMapView
import com.amap.api.maps.model.BitmapDescriptor
import com.amap.api.maps.model.BitmapDescriptorFactory
import com.amap.api.maps.model.CameraPosition
import com.amap.api.maps.model.CustomMapStyleOptions
import com.amap.api.maps.model.LatLng
import com.amap.api.maps.model.LatLngBounds
import com.amap.api.maps.model.Marker
import com.amap.api.maps.model.MarkerOptions
import com.amap.api.maps.model.Polyline
import com.amap.api.maps.model.PolylineOptions
import com.mogo.eagle.core.data.map.MogoLocation
import com.mogo.eagle.core.function.api.autopilot.IMoGoChassisLocationGCJ02Listener
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
import com.mogo.och.common.module.manager.autopilot.location.OchLocationManager
import com.mogo.och.taxi.R
import com.mogo.och.taxi.utils.TaxiMapAssetStyleUtil
/**
* taxi司机端前往目的地小地图导航
*/
class TaxiMapDirectionView @JvmOverloads constructor(
context: Context,
attrs: AttributeSet? = null,
defStyleAttr: Int = 0
) : RelativeLayout(context, attrs, defStyleAttr), IMoGoChassisLocationGCJ02Listener,
ITaxiMapDirectionView, AMap.OnCameraChangeListener {
private lateinit var mAMapNaviView: TextureMapView
private lateinit var mAMap: AMap
private var mCarMarker: Marker? = null
private lateinit var mStartMarker: Marker
private lateinit var mEndMarker: Marker
private val zoomLevel = 13
private val routeArrivied: MutableList<LatLng> = ArrayList()
private val routeArriving: MutableList<LatLng> = ArrayList()
private var location: MogoLocation? = null
private var startStation: LatLng? = null
private var endStation: LatLng? = null
private var mPolyline: Polyline? = null
var textureList: MutableList<BitmapDescriptor?> = ArrayList()
var texIndexList: MutableList<Int> = ArrayList()
private var mArrivedRes: BitmapDescriptor? = null
private var mUnArrivedRes: BitmapDescriptor? = null
init {
try {
initView(context)
} catch (e: Exception) {
e.printStackTrace()
}
}
private fun initView(context: Context) {
d(SceneConstant.M_TAXI + TAG, "initView")
val smpView = LayoutInflater.from(context).inflate(R.layout.taxi_map_view, this)
mAMapNaviView = smpView.findViewById(R.id.taxi_amap_view)
initAMapView()
// 注册定位监听
OchLocationManager.addGCJ02Listener(TAG, 3, this)
}
override fun onDetachedFromWindow() {
super.onDetachedFromWindow()
// 注册定位监听
OchLocationManager.removeGCJ02Listener(TAG)
}
private fun initAMapView() {
val mCameraUpdate = CameraUpdateFactory.zoomTo(zoomLevel.toFloat())
mAMap = mAMapNaviView.map
// 设置导航地图模式，aMap是地图控制器对象。
mAMap.mapType = AMap.MAP_TYPE_NIGHT
// 关闭显示实时路况图层，aMap是地图控制器对象。
mAMap.isTrafficEnabled = false
// 设置 锚点 图标
mCarMarker = mAMap.addMarker(MarkerOptions().icon(BitmapDescriptorFactory.fromResource(R.drawable.taxi_map_car)).anchor(0.5f, 0.5f))
mStartMarker = mAMap.addMarker(MarkerOptions().icon(BitmapDescriptorFactory.fromResource(R.drawable.taxi_map_view_dir_start)))
mEndMarker = mAMap.addMarker(MarkerOptions().icon(BitmapDescriptorFactory.fromResource(R.drawable.taxi_map_view_dir_end)))
mStartMarker.isVisible = false
mEndMarker.isVisible = false
mArrivedRes = BitmapDescriptorFactory.fromResource(R.drawable.taxi_map_arrow_arrived)
mUnArrivedRes = BitmapDescriptorFactory.fromResource(R.drawable.taxi_map_arrow_un_arrive)
// 加载自定义样式
val customMapStyleOptions = CustomMapStyleOptions()
.setEnable(true)
.setStyleData(TaxiMapAssetStyleUtil.getAssetsStyle(context, "map_style.data"))
.setStyleExtraData(
TaxiMapAssetStyleUtil.getAssetsExtraStyle(
context,
"map_style_extra.data"
)
)
// 设置自定义样式
mAMap.setCustomMapStyle(customMapStyleOptions)
//设置希望展示的地图缩放级别
mAMap.moveCamera(mCameraUpdate)
// 设置地图的样式
mAMap.uiSettings.apply {
isZoomControlsEnabled = false // 地图缩放级别的交换按钮
setAllGesturesEnabled(false) // 所有手势
isMyLocationButtonEnabled = false // 显示默认的定位按钮
setLogoBottomMargin(-150) //设置Logo下边界距离屏幕底部的边距,设置为负值即可
}
mAMap.setOnMapLoadedListener(AMap.OnMapLoadedListener {
d(SceneConstant.M_TAXI + TAG, "smp---onMapLoaded")
// 加载自定义样式
val customMapStyleOptions = CustomMapStyleOptions()
.setEnable(true)
.setStyleData(TaxiMapAssetStyleUtil.getAssetsStyle(context, "map_style.data"))
.setStyleExtraData(
TaxiMapAssetStyleUtil.getAssetsExtraStyle(
context,
"map_style_extra.data"
)
)
// 设置自定义样式
mAMap.setCustomMapStyle(customMapStyleOptions)
mAMapNaviView.map.setPointToCenter(
mAMapNaviView.width / 2,
mAMapNaviView.height / 2
)
})
//设置地图状态的监听接口
mAMap.setOnCameraChangeListener(this)
}
override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
return true
}
override fun onChassisLocationGCJ02(mogoLocation: MogoLocation?) {
if (mogoLocation == null) {
return
}
try {
val currentLatLng = LatLng(mogoLocation.latitude, mogoLocation.longitude)
if (mPolyline != null && mPolyline!!.points.size > 1) {
val points = mPolyline!!.points
//圈定地图显示范围
val endLatLng = points[points.size - 1]
//存放经纬度
val boundsBuilder = LatLngBounds.Builder()
boundsBuilder.include(currentLatLng)
boundsBuilder.include(endLatLng)
//第二个参数为四周留空宽度
mAMap.moveCamera(
CameraUpdateFactory.newLatLngBoundsRect(boundsBuilder.build(), 100, 100, 100, 100)
)
} else {
//设置希望展示的地图缩放级别
val cameraPosition = CameraPosition.Builder()
.target(mCarMarker!!.position).tilt(0f).bearing(mogoLocation.heading.toFloat())
.zoom(zoomLevel.toFloat()).build()
mAMap.moveCamera(CameraUpdateFactory.newCameraPosition(cameraPosition))
}
//更新车辆位置
if (mCarMarker != null) {
mCarMarker!!.rotateAngle = (360 - mogoLocation.heading).toFloat()
mCarMarker!!.position = currentLatLng
mCarMarker!!.setToTop()
}
} catch (e: Exception) {
e.printStackTrace()
}
}
override fun setLineMarker() {
if (mStartMarker.isVisible && mEndMarker.isVisible
) {
return
}
if (startStation != null && endStation != null) {
// 设置开始结束Marker位置
mStartMarker.position = startStation
mStartMarker.isVisible = true
mEndMarker.position = endStation
mEndMarker.isVisible = true
}
}
override fun drawablePolyline() {
if (routeArrivied.isEmpty() && routeArriving.isEmpty()) {
d(SceneConstant.M_TAXI + TAG, "没有点")
return
}
texIndexList.clear()
val allPoints = ArrayList(routeArrivied)
for (i in routeArrivied.indices) {
if (routeArrivied.size > 1 && i < routeArrivied.size - 1) {
texIndexList.add(0)
}
}
texIndexList.add(0)
allPoints.add(LatLng(location!!.latitude, location!!.longitude))
allPoints.addAll(routeArriving)
for (ignored in routeArrivied) {
texIndexList.add(1)
}
if (mPolyline != null) {
mPolyline!!.points = allPoints
mPolyline!!.options.customTextureIndex = texIndexList
return
}
if(textureList.isEmpty()) {
textureList.add(mArrivedRes)
textureList.add(mUnArrivedRes)
}
//设置线段纹理
val polylineOptions = PolylineOptions().apply {
addAll(allPoints)
isUseTexture = true
width(15f)
lineCapType(PolylineOptions.LineCapType.LineCapRound)
customTextureList = textureList
customTextureIndex = texIndexList
}
// 绘制线
mPolyline = mAMap.addPolyline(polylineOptions)
}
override fun clearPolyline() {
if (mPolyline != null) {
mPolyline!!.remove()
mPolyline = null
}
mStartMarker.isVisible = false
mEndMarker.isVisible = false
}
fun onCreateView(savedInstanceState: Bundle?) {
mAMapNaviView.onCreate(savedInstanceState)
}
fun onResume() {
mAMapNaviView.onResume()
}
fun onPause() {
mAMapNaviView.onPause()
}
fun onDestroy() {
mAMapNaviView.onDestroy()
mAMap.clear()
}
fun setStartMarkAndEndMark(startStation: LatLng?, endStation: LatLng?) {
this.startStation = startStation
this.endStation = endStation
}
fun setCoordinatesLatLng(
routeArrivied: List<LatLng>?,
routeArriving: List<LatLng>?,
location: MogoLocation?
) {
this.routeArrivied.clear()
this.routeArrivied.addAll(routeArrivied!!)
this.routeArriving.clear()
this.routeArriving.addAll(routeArriving!!)
this.location = location
}
override fun onCameraChange(cameraPosition: CameraPosition) {}
override fun onCameraChangeFinish(cameraPosition: CameraPosition) {}
companion object {
//小地图名称
const val TAG = "TaxiMapDirectionView"
}
}

136
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiOperationDatasFragment.java
View File

@@ -1,136 +0,0 @@
package com.mogo.och.taxi.ui;
import android.content.Context;
import android.os.Bundle;
import android.text.Html;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.mogo.och.common.module.utils.DateTimeUtil;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.model.TaxiModel;
import java.util.ArrayList;
import java.util.List;
/**
* @author: wangmingjun
* @date: 2021/9/10
*/
public class TaxiOperationDatasFragment extends BaseTaxiUIFragment {
private RecyclerView mRecyclerView;
private static Context mContext;
private List<Long> mDurationData = new ArrayList<>();
private List<Long> mOrderNumData = new ArrayList<>();
private List<Long> mData = new ArrayList<>();
private static int mType = 0;//0: 运营时长 1：运营单数
private OperationDataAdapter mAdapter;
public static TaxiOperationDatasFragment newInstance(Context context, int type) {
mContext = context;
mType = type;
Bundle args = new Bundle();
TaxiOperationDatasFragment fragment = new TaxiOperationDatasFragment();
fragment.setArguments(args);
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_operation_data_view;
}
@Override
protected void initViews(View view) {
mRecyclerView = view.findViewById(R.id.operation_data_recycler_view);
mRecyclerView.setLayoutManager(new LinearLayoutManager(mContext));
mAdapter = new OperationDataAdapter(mContext, mData);
mRecyclerView.setAdapter(mAdapter);
initDatas();
}
private void initDatas() {
TaxiModel.getInstance().queryDriverServiceData();
}
public void setmType(int type) {
mType = type;
mData.clear();
if (mType == 0){
mData.addAll(mDurationData);
}else if (mType == 1){
mData.addAll(mOrderNumData);
}
if (mAdapter != null) mAdapter.notifyDataSetChanged();
}
public void updateData(long dailyTimeDuration, long dailyOrderNum) {
mDurationData.clear();
mOrderNumData.clear();
mData.clear();
mDurationData.add(dailyTimeDuration);
mOrderNumData.add(dailyOrderNum);
mData.addAll(mDurationData);
if (mAdapter != null) mAdapter.notifyDataSetChanged();
}
class OperationDataAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private List<Long> datas;
private Context context;
public OperationDataAdapter(Context context, List<Long> datas) {
this.datas = datas;
this.context = context;
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(context).inflate(R.layout.taxi_operation_data_item_view, parent, false);
OperationDataViewHolder viewHolder = new OperationDataViewHolder(view);
return viewHolder;
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
if (holder instanceof OperationDataViewHolder) {
OperationDataViewHolder viewHolder = (OperationDataViewHolder) holder;
if (0 == mType){
String hourData = TextUtils.isEmpty(DateTimeUtil.secondsToHourStr(datas.get(position))) ? "0": DateTimeUtil.secondsToHourStr(datas.get(position));
String minuteData = DateTimeUtil.secondsToMinuteStr(datas.get(position));
String data = "<font><b><big><big><big>" + hourData + "</big></big></big></b> 时 </font>" + "<font><b><big><big><big>" + minuteData + "</big></big></big></b> 分</font>";
viewHolder.operationDataTv.setText(Html.fromHtml(data));
viewHolder.operationDataTitle.setText("今日在线时长");
}else if (1 == mType){
String data = "<font><b><big><big><big>" + String.valueOf(datas.get(position)) + "</big></big></big></b>" + " 单" + "</font>";
viewHolder.operationDataTv.setText(Html.fromHtml(data));
viewHolder.operationDataTitle.setText("今日订单完成数");
}
}
}
@Override
public int getItemCount() {
return datas.size();
}
}
class OperationDataViewHolder extends RecyclerView.ViewHolder {
private TextView operationDataTv;
private TextView operationDataTitle;
public OperationDataViewHolder(@NonNull View itemView) {
super(itemView);
operationDataTv = itemView.findViewById(R.id.operation_data_tv);
operationDataTitle = itemView.findViewById(R.id.operation_data_title_tv);
}
}
}

231
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiOrderCancelDialog.java
View File

@@ -1,231 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.app.AlertDialog;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.Display;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.TextView;
import androidx.annotation.RequiresApi;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.ToastUtils;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.constant.TaxiOrderCancelReasons;
import java.lang.ref.WeakReference;
/**
* @author: wangmingjun
* @date: 2021/8/18
*/
public class TaxiOrderCancelDialog extends AlertDialog implements View.OnClickListener,AdapterView.OnItemClickListener {
private static final String TAG = "OCHTaxiOrderCancelDial";
protected WeakReference<Context> contextWeakReference;
private GridView mContentView;
private TextView mCancelCommitTv;
private TextView mDialogCancelTv;
private String mCurrentReason = "";
private ContentAdapter mContentAdapter;
private int mOrderStatus;//1：预约单，其他为即时单的状态， 主要是控制乘客上车 乘客下车这几个选项的显示
private String[] mContentArrays;
private WeakReference<TaxiFragment> mOchTaxiFragmentWeak;
private String mOrderNo;
protected TaxiOrderCancelDialog(TaxiFragment fragment, Context context, String orderNo, int orderStatus) {
super(context,R.style.OrderCancelDialog);
mOrderNo = orderNo;
mOchTaxiFragmentWeak = new WeakReference<>(fragment);
this.mOrderStatus = orderStatus;
contextWeakReference = new WeakReference<>(context);
initReasonArray();
}
private void initReasonArray() {
if (1 == mOrderStatus) {
mContentArrays = new String[]{TaxiOrderCancelReasons.BookPassengerCancel.getMsg(), TaxiOrderCancelReasons.CarBroken.getMsg(),
TaxiOrderCancelReasons.BookJourneyConflict.getMsg(), TaxiOrderCancelReasons.BatteryLow.getMsg(),
TaxiOrderCancelReasons.BookOther.getMsg()};
return;
}
TaxiOrderStatusEnum ochStatus = TaxiOrderStatusEnum.valueOf(mOrderStatus);
switch (ochStatus) {
case OnTheWayToStart:
mContentArrays = new String[]{TaxiOrderCancelReasons.CarBroken.getMsg(), TaxiOrderCancelReasons.DeviceBroken.getMsg(),
TaxiOrderCancelReasons.BatteryLow.getMsg(), TaxiOrderCancelReasons.DriverIsIll.getMsg(),
TaxiOrderCancelReasons.StartStationFaraway.getMsg(), TaxiOrderCancelReasons.Other.getMsg(),
TaxiOrderCancelReasons.PassengerCancel.getMsg()};
break;
case ArriveAtStart:
mContentArrays = new String[]{TaxiOrderCancelReasons.CarBroken.getMsg(), TaxiOrderCancelReasons.DeviceBroken.getMsg(),
TaxiOrderCancelReasons.BatteryLow.getMsg(), TaxiOrderCancelReasons.DriverIsIll.getMsg(),
TaxiOrderCancelReasons.PassengerNotArrive.getMsg(),TaxiOrderCancelReasons.UnContractPassenger.getMsg(),
TaxiOrderCancelReasons.PassengerCancel.getMsg(),TaxiOrderCancelReasons.Other.getMsg()};
break;
case OnTheWayToEnd:
case ArriveAtEnd:
mContentArrays = new String[]{TaxiOrderCancelReasons.CarBroken.getMsg(), TaxiOrderCancelReasons.DeviceBroken.getMsg(),
TaxiOrderCancelReasons.BatteryLow.getMsg(), TaxiOrderCancelReasons.DriverIsIll.getMsg(),
TaxiOrderCancelReasons.PassengerStopOver.getMsg(),TaxiOrderCancelReasons.Other.getMsg()};
break;
default:
mContentArrays = new String[]{TaxiOrderCancelReasons.CarBroken.getMsg(), TaxiOrderCancelReasons.DeviceBroken.getMsg(),
TaxiOrderCancelReasons.BatteryLow.getMsg(), TaxiOrderCancelReasons.DriverIsIll.getMsg(),
TaxiOrderCancelReasons.PassengerNotArrive.getMsg(), TaxiOrderCancelReasons.PassengerStopOver.getMsg(),
TaxiOrderCancelReasons.Other.getMsg()};
break;
}
}
protected TaxiOrderCancelDialog(Context context, boolean cancelable, OnCancelListener cancelListener) {
super(context, cancelable, cancelListener);
}
protected TaxiOrderCancelDialog(Context context, int themeResId) {
super(context, themeResId);
}
@RequiresApi(api = Build.VERSION_CODES.M)
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().setBackgroundDrawableResource(R.drawable.taxi_order_cancel_dialog_bg);
setContentView(R.layout.taxi_order_cancel_view);
initView();
setCancelable(false);
setCanceledOnTouchOutside(false);
initWindowView();
}
private void initWindowView() {
Window window = getWindow();
//dialog padding 去掉
window.getDecorView().setPadding(0,0,0,0);
window.setDimAmount(0.5f);
window.getDecorView().setBackgroundColor(Color.parseColor("#00FFFFFF"));//设置背景， 不然显示不全
WindowManager.LayoutParams params = window.getAttributes();
window.setGravity(Gravity.CENTER);
WindowManager m = window.getWindowManager();
Display d = m.getDefaultDisplay();
params.height = d.getHeight() - 500;
window.setAttributes(params);
}
@RequiresApi(api = Build.VERSION_CODES.M)
private void initView() {
mContentView = findViewById(R.id.module_och_taxi_order_cancel_content_gv);
mCancelCommitTv = findViewById(R.id.order_cancel_commit_tv);
mDialogCancelTv = findViewById(R.id.order_dialog_cancel_tv);
mContentAdapter = new ContentAdapter(contextWeakReference.get(), mContentArrays);
mContentView.setAdapter(mContentAdapter);
mContentView.setSelector(new ColorDrawable(Color.TRANSPARENT));
mContentView.setOnItemClickListener(this);
mCancelCommitTv.setOnClickListener(this);
mDialogCancelTv.setOnClickListener(this);
mContentView.setOnItemClickListener(this);
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.order_cancel_commit_tv) {//bt commit
if (!TextUtils.isEmpty(mCurrentReason) && TaxiOrderCancelReasons.getType(mCurrentReason) != 0) {
if (1 == mOrderStatus){//预约单
mOchTaxiFragmentWeak.get().cancelOrderById(mOrderNo, TaxiOrderCancelReasons.getType(mCurrentReason),mCurrentReason);
}else {//即时单
mOchTaxiFragmentWeak.get().cancelCurOrder(TaxiOrderCancelReasons.getType(mCurrentReason),mCurrentReason);
}
dismiss();
}else {
ToastUtils.showShort("取消原因不能为空");
}
}else if (v.getId() == R.id.order_dialog_cancel_tv){//close icon
mCurrentReason = "";
dismiss();
}
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
CallerLogger.d(M_TAXI + TAG,"mCurrentReason ="+ mContentArrays[position]);
mCurrentReason = mContentArrays[position];
// GradientDrawable background = (GradientDrawable) mCancelBt.getBackground();//GradientDrawable是Drawable的子类
// background.setColor(Color.parseColor("#2B6EFF"));
// mCancelBt.setTextColor(Color.parseColor("#FFFFFF"));
// mCancelBt.setClickable(true);
mContentAdapter.notifyCurrentReasons(mCurrentReason);
}
class ContentAdapter extends BaseAdapter{
private Context context;
private String[] datas;
private LayoutInflater layoutInflater;
private String currentReasons = "";
public ContentAdapter(Context context, String[] array){
this.context = context;
datas = array;
layoutInflater = LayoutInflater.from(context);
}
@Override
public int getCount() {
return datas.length;
}
@Override
public Object getItem(int position) {
return datas[position];
}
@Override
public long getItemId(int position) {
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder viewHolder = null;
if (convertView == null){
convertView = layoutInflater.inflate(R.layout.taxi_order_checkbox_item,null);
viewHolder = new ViewHolder();
viewHolder.checkBoxTv = convertView.findViewById(R.id.item_checkbox);
convertView.setTag(viewHolder);
}else {
viewHolder = (ViewHolder) convertView.getTag();
}
viewHolder.checkBoxTv.setText(datas[position]);
if(viewHolder.checkBoxTv.getText().toString().equals(currentReasons)){
viewHolder.checkBoxTv.setCompoundDrawablesWithIntrinsicBounds(context.getResources().getDrawable(R.drawable.shape_size_taxi_selected_btn),null,null,null);
}else {
viewHolder.checkBoxTv.setCompoundDrawablesWithIntrinsicBounds(context.getResources().getDrawable(R.drawable.shape_size_taxi_unselected_btn),null,null,null);
}
return convertView;
}
public void notifyCurrentReasons(String reason){
currentReasons = reason;
notifyDataSetChanged();
}
class ViewHolder {
TextView checkBoxTv;
}
}
}

522
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiPersonalDialogFragment.java
View File

@@ -1,522 +0,0 @@
package com.mogo.och.taxi.ui;
import android.app.Dialog;
import android.content.Context;
import android.graphics.Color;
import android.graphics.Point;
import android.graphics.Typeface;
import android.os.Build;
import android.os.Bundle;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;
import com.mogo.commons.mvp.MvpDialogFragment;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.och.common.module.utils.DateTimeUtil;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.taxi.constant.TaxiOrderTypeEnum;
import com.mogo.och.taxi.presenter.TaxiOperationalPresenter;
import com.mogo.och.taxi.ui.base.AvoidLeakDialog;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import me.jessyan.autosize.utils.AutoSizeUtils;
/**
* @author: wangmingjun
* @date: 2021/8/18
*/
public class TaxiPersonalDialogFragment extends
MvpDialogFragment<TaxiPersonalDialogFragment, TaxiOperationalPresenter>
implements View.OnClickListener {
private final static String TAG = "OCHTaxiOrdersDialog";
private RelativeLayout mOperationDataRl;
private ImageView mCloseIv;
private RecyclerView mOrdersRv;
private Button mShowOrdersBt;
private TabLayout mOperationTab;
private ViewPager mOperationViewPager;
private OrderAdapter mAdapter;
private ConstraintLayout mNoDatas;
private final List<OrderQueryRespBean.Result> orders = new ArrayList<>();
private final String[] mTabTitles = {"在线时长","订单完成数"};
private final List<TaxiOperationDatasFragment> fragments = new ArrayList<>();
private int mNextPage = 1;//订单列表分页从1开始
private final int mPerPageSize = 10;
private static boolean serverHadNoData = false;
@NonNull
@Override
public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
AvoidLeakDialog dialog = new AvoidLeakDialog(getContext());
dialog.setHostFragmentReference(this);
return dialog;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_orders_list_view;
}
@Override
protected void initViews() {
initView();
}
@NonNull
@Override
protected TaxiOperationalPresenter createPresenter() {
return new TaxiOperationalPresenter(this);
}
@Override
public String getTagName() {
return TAG;
}
@Override
public void dismissAllowingStateLoss() {
super.dismissAllowingStateLoss();
}
@Override
public void onStart() {
super.onStart();
setCancelable(false);
getDialog().setCanceledOnTouchOutside(true);
Window window = getDialog().getWindow();
//dialog padding 去掉
window.getDecorView().setPadding(0,0,0,0);
window.setDimAmount(0f);
WindowManager.LayoutParams params = window.getAttributes();
params.x = 0;
params.y = 0;
WindowManager windowManager = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
Point point = new Point();
windowManager.getDefaultDisplay().getSize(point);
params.width = (int)(point.x * 0.375);
params.height = ViewGroup.LayoutParams.MATCH_PARENT;
CallerLogger.d(M_TAXI + TAG,"width= "+params.width+"height= "+params.height);
window.setAttributes(params);
window.getDecorView().setBackgroundColor(Color.parseColor("#00FFFFFF"));//设置背景， 不然显示不全
window.setGravity(Gravity.LEFT|Gravity.BOTTOM);
}
private void initView() {
initOperationTabDatas();
mCloseIv = findViewById(R.id.module_och_taxi_order_list_close_iv);
mOperationDataRl = findViewById(R.id.module_och_taxi_operation_data_rl);
mShowOrdersBt = findViewById(R.id.module_och_taxi_order_list_show_bt);
mOrdersRv = findViewById(R.id.module_och_taxi_order_list);
mNoDatas = findViewById(R.id.no_order_data_view);
ImageView imageView = findViewById(R.id.no_order_data_iv);
imageView.setImageResource(R.drawable.no_order_data);
ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams)imageView.getLayoutParams();
params.width = 480;
params.height = 480;
imageView.setLayoutParams(params);
mOrdersRv.setVisibility(View.GONE);
mNoDatas.setVisibility(View.GONE);
mShowOrdersBt.setOnClickListener(this);
mCloseIv.setOnClickListener(this);
}
private void initOperationTabDatas() {
mOperationTab = findViewById(R.id.operation_data_tablayout);
mOperationViewPager = findViewById(R.id.operation_data_viewpager);
for (int i= 0;i < mTabTitles.length; i++){
TabLayout.Tab tab = mOperationTab.newTab();
tab.view.setBackgroundColor(Color.parseColor("#00000000"));
View tabView = View.inflate(getContext(),R.layout.taxi_operation_tab_item_custom,null);
TextView tv = tabView.findViewById(R.id.operation_tab_title);
tv.setText(mTabTitles[i]);
tab.setCustomView(tabView);
if (0 == i){
mOperationTab.addTab(tab,true);
changeOperationTabLayoutTabUI(tab,true);
fragments.add(TaxiOperationDatasFragment.newInstance(getActivity(),0));
}else if (1 == i){
mOperationTab.addTab(tab);
changeOperationTabLayoutTabUI(tab,false);
fragments.add(TaxiOperationDatasFragment.newInstance(getActivity(),1));
}
}
mOperationTab.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
@Override
public void onTabSelected(TabLayout.Tab tab) {
mOperationViewPager.setCurrentItem(tab.getPosition());
changeOperationTabLayoutTabUI(tab,true);
fragments.get(tab.getPosition()).setmType(tab.getPosition());
}
@Override
public void onTabUnselected(TabLayout.Tab tab) {
changeOperationTabLayoutTabUI(tab,false);
}
@Override
public void onTabReselected(TabLayout.Tab tab) {
}
});
mOperationViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@Override
public void onPageSelected(int position) {
mOperationTab.getTabAt(position).select();
}
@Override
public void onPageScrollStateChanged(int state) {
}
});
mOperationViewPager.setAdapter(new OrdersOperationFragmentAdapter(
getChildFragmentManager(), FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT));
fragments.get(0).setmType(0);
}
public void onServiceDataUpdate(long dailyTimeDuration, long dailyOrderNum){
for (int i=0; i< fragments.size();i++){
fragments.get(i).updateData(dailyTimeDuration,dailyOrderNum);
}
}
private void changeOperationTabLayoutTabUI(TabLayout.Tab tab, boolean isSelected) {
TextView textView = (TextView) tab.getCustomView().findViewById(R.id.operation_tab_title);
ImageView imageView = (ImageView) tab.getCustomView().findViewById(R.id.operation_tab_line_iv);
if (isSelected){
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX,AutoSizeUtils.dp2px(getContext(),46));
CallerLogger.d(M_TAXI + TAG,"SelectTv = "+ textView.getText());
textView.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
textView.setTextColor(Color.parseColor("#FFFFFF"));
if(getContext()!=null) {
imageView.setImageDrawable(getResources().getDrawable(R.drawable.taxi_driver_operation_tab_line));
}
}else {
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX,AutoSizeUtils.dp2px(getContext(),40));
CallerLogger.d(M_TAXI + TAG,"unSelectTv = "+ textView.getText());
textView.setTypeface(Typeface.defaultFromStyle(Typeface.NORMAL));
textView.setTextColor(Color.parseColor("#A7B6F0"));
imageView.setImageDrawable(null);
}
}
@Override
public void onClick(View v) {
if (v.getId() == R.id.module_och_taxi_order_list_close_iv){
dismiss();
}else {
mOrdersRv.setVisibility(View.VISIBLE);
mOperationDataRl.setVisibility(View.GONE);
mNoDatas.setVisibility(View.GONE);
initOrdersView();
mPresenter.queryOrdersList(mNextPage, mPerPageSize);
}
}
private void initOrdersView() {
mAdapter = new OrderAdapter(getContext(),orders);
LinearLayoutManager manager = new LinearLayoutManager(getContext());
mOrdersRv.setLayoutManager(manager);
mOrdersRv.addOnScrollListener(new OnTaxiOrderRvOnScrollListener() {
@Override
public void onLoadMore() {
if (!serverHadNoData){
mPresenter.queryOrdersList(mNextPage, mPerPageSize);
}
}
});
mOrdersRv.setAdapter(mAdapter);
}
public void onOrdersListPageRefresh(List<OrderQueryRespBean.Result> ordersList){
try {
if (null == ordersList && mNextPage == 0 ||
(ordersList != null && ordersList.size() == 0)){//无数据
mOrdersRv.setVisibility(View.GONE);
mNoDatas.setVisibility(View.VISIBLE);
return;
}
mOrdersRv.setVisibility(View.VISIBLE);
mNoDatas.setVisibility(View.GONE);
if ((null == ordersList) || (ordersList.size() < mPerPageSize && mNextPage > 0)){//已经没有更多数据，提示无数据
//已经没有更多数据
serverHadNoData = true;
orders.addAll(ordersList);
mAdapter.notifyDataSetChanged();
mNextPage = mNextPage +1;
return;
}
serverHadNoData = false;
orders.addAll(ordersList);
if(mAdapter!=null) {
mAdapter.notifyDataSetChanged();
}
mNextPage = mNextPage +1;
}catch (Exception e){
e.fillInStackTrace();
}
}
class OrderAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>{
private static final int ORDER_DETAIL_ITEM = 0;
private static final int DAY_GROUP_ITEM = 1;
private Context context;
List<OrderQueryRespBean.Result> orders;
public OrderAdapter(Context context,List<OrderQueryRespBean.Result> datas){
this.context = context;
this.orders = datas;
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
if (viewType == ORDER_DETAIL_ITEM){
View view = LayoutInflater.from(context).inflate(R.layout.taxi_orders_list_item,parent,false);
return new OrderDetailViewHolder(view);
}else if (viewType == DAY_GROUP_ITEM){
View view = LayoutInflater.from(context).inflate(R.layout.taxi_orders_list_day_item,parent,false);
return new DayGroupViewHolder(view);
}
return null;
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
OrderQueryRespBean.Result queryRespBean = orders.get(position);
if (null == queryRespBean) return;
if (holder instanceof DayGroupViewHolder){
DayGroupViewHolder groupViewHolder = (DayGroupViewHolder)holder;
groupViewHolder.dayGroupTv.setText(DateTimeUtil.getYMDTime(queryRespBean.createTime));
bindOrderDetailData(queryRespBean,groupViewHolder.orderTimeTv,groupViewHolder.startStationTv,groupViewHolder.endStationTv,
groupViewHolder.orderStatusBt,groupViewHolder.orderTypeBt,groupViewHolder.orderNumTv);
if (isNoLineItem(position)){
groupViewHolder.dividerLine.setVisibility(View.VISIBLE);
}else {
groupViewHolder.dividerLine.setVisibility(View.GONE);
}
if (position == orders.size()-1 && serverHadNoData){
groupViewHolder.mBootNoDataView.setVisibility(View.VISIBLE);
}else {
groupViewHolder.mBootNoDataView.setVisibility(View.GONE);
}
}else if (holder instanceof OrderDetailViewHolder){
OrderDetailViewHolder detailViewHolder = (OrderDetailViewHolder)holder;
bindOrderDetailData(queryRespBean,detailViewHolder.orderTimeTv,detailViewHolder.startStationTv,detailViewHolder.endStationTv,
detailViewHolder.orderStatusBt,detailViewHolder.orderTypeBt,detailViewHolder.orderNumTv);
if (isNoLineItem(position)){
detailViewHolder.dividerLine.setVisibility(View.VISIBLE);
}else {
detailViewHolder.dividerLine.setVisibility(View.GONE);
}
if (position == orders.size()-1 && serverHadNoData){
detailViewHolder.mBootNoDataView.setVisibility(View.VISIBLE);
}else {
detailViewHolder.mBootNoDataView.setVisibility(View.GONE);
}
}
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public int getItemViewType(int position) {
//第一个要显示时间
if (position == 0){
return DAY_GROUP_ITEM;
}
String currentDate = DateTimeUtil.getYMDTime(orders.get(position).createTime);//获取当前订单时间
int prevIndex = position - 1;
String preDate = DateTimeUtil.getYMDTime(orders.get(prevIndex).createTime);
boolean isDifferent = !preDate.equals(currentDate);//前一个订单的日期跟第二个订单的日期是否一致
return isDifferent ? DAY_GROUP_ITEM : ORDER_DETAIL_ITEM;//一样订单详情， 不一样新添加分组
}
private boolean isNoLineItem(int position){
if (position == orders.size() -1){
return false;
}else {
String currentDate = DateTimeUtil.getYMDTime(orders.get(position).createTime);//获取当前订单时间
int nextIndex = position + 1;
String preDate = DateTimeUtil.getYMDTime(orders.get(nextIndex).createTime);
return preDate.equals(currentDate);//一样有划分线， 不一样没有划分线
}
}
@Override
public int getItemCount() {
return orders.size();
}
private void bindOrderDetailData(OrderQueryRespBean.Result queryRespBean, TextView orderTimeTv, TextView startStationTv, TextView endStationTv,
Button orderStatusBt, Button orderTypeBt, TextView orderNumTv){
Calendar calendar= Calendar.getInstance();
calendar.setTimeInMillis(queryRespBean.createTime);
orderTimeTv.setText(DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.HH_mm));
startStationTv.setText(queryRespBean.startSiteAddr);
endStationTv.setText(queryRespBean.endSiteAddr);
orderStatusBt.setText(getOrderStatus(queryRespBean.orderStatus,orderStatusBt));
orderTypeBt.setText(getOrderType(queryRespBean.orderType,orderTypeBt));
orderNumTv.setText("订单编号："+String.valueOf(queryRespBean.orderNo));
}
private String getOrderStatus(int status, Button button){
TaxiOrderStatusEnum orderStatus = TaxiOrderStatusEnum.valueOf(status);
switch (orderStatus){
case JourneyCompleted:
button.setBackground(context.getDrawable(R.drawable.taxi_order_button_status_canceled_bg));
return "已完成";
case Cancel:
button.setBackground(context.getDrawable(R.drawable.taxi_order_button_status_canceled_bg));
return "已取消";
default:
button.setBackground(context.getDrawable(R.drawable.taxi_order_button_status_bg));
return "服务中";
}
}
private String getOrderType(int type, Button button){
if (type == TaxiOrderTypeEnum.Reserved.getType()){
button.setBackground(context.getDrawable(R.drawable.taxi_order_button_type_reserver_bg));
return "预约单";
}else{
button.setBackground(context.getDrawable(R.drawable.taxi_order_button_type_bg));
return "即时单";
}
}
}
class OrderDetailViewHolder extends RecyclerView.ViewHolder{
protected TextView orderTimeTv;
protected Button orderStatusBt;
protected TextView startStationTv;
protected TextView endStationTv;
protected TextView orderNumTv;
protected Button orderTypeBt;
protected View dividerLine;
protected View mBootNoDataView;
public OrderDetailViewHolder(@NonNull View itemView) {
super(itemView);
orderTimeTv = itemView.findViewById(R.id.order_time_hm_tv);
orderStatusBt = itemView.findViewById(R.id.order_status_bt);
startStationTv = itemView.findViewById(R.id.grab_order_start_station);
endStationTv = itemView.findViewById(R.id.grab_order_end_station);
orderNumTv = itemView.findViewById(R.id.order_num);
orderTypeBt = itemView.findViewById(R.id.order_type_bt);
dividerLine = itemView.findViewById(R.id.module_och_taxi_order_divider);
mBootNoDataView = itemView.findViewById(R.id.boot_refresh_no_data_view);
}
}
class DayGroupViewHolder extends OrderDetailViewHolder{
private TextView dayGroupTv;
public DayGroupViewHolder(@NonNull View itemView) {
super(itemView);
dayGroupTv = itemView.findViewById(R.id.order_day_tv);
}
}
abstract class OnTaxiOrderRvOnScrollListener extends RecyclerView.OnScrollListener{
private boolean isUpwardSliding = false;
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
//不滑动
if (manager instanceof LinearLayoutManager && newState == SCROLL_STATE_IDLE){
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) manager;
int lastItemPosition = linearLayoutManager.findLastCompletelyVisibleItemPosition();
int itemCount = linearLayoutManager.getItemCount();
CallerLogger.d(M_TAXI + TAG,"lastItemPosition=="+lastItemPosition+",itemCount=="+itemCount);
//向上滑动到最后一个
if ((lastItemPosition == itemCount-1) && isUpwardSliding){
onLoadMore();
}
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
isUpwardSliding = dy > 0;
}
public abstract void onLoadMore();
}
@Override
public void dismiss() {
super.dismiss();
mNextPage = 0;
orders.clear();
}
private class OrdersOperationFragmentAdapter extends FragmentPagerAdapter{
public OrdersOperationFragmentAdapter(@NonNull FragmentManager fm, int behavior) {
super(fm, behavior);
}
@NonNull
@Override
public Fragment getItem(int position) {
return fragments.get(position);
}
@Override
public int getCount() {
return fragments.size();
}
@Nullable
@Override
public CharSequence getPageTitle(int position) {
return mTabTitles[position];
}
}
}

186
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiReserveOrdersFragment.java
View File

@@ -1,186 +0,0 @@
package com.mogo.och.taxi.ui;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
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.constraintlayout.widget.ConstraintLayout;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import com.mogo.eagle.core.utilcode.util.ToastUtils;
import com.mogo.och.common.module.utils.DateTimeUtil;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import static androidx.recyclerview.widget.RecyclerView.SCROLL_STATE_IDLE;
/**
* @author: wangmingjun
* @date: 2021/9/2
* 待服务订单列表
*/
public class TaxiReserveOrdersFragment extends BaseTaxiUIFragment {
private RecyclerView mRecyclerView;
private TextView mNodataTv;
private ConstraintLayout mNoDataView;
private View mBootRefreshNoDataView;
private List<OrderQueryRespBean.Result> mDatas = new ArrayList<>();
private ToBeServedOrdersAdapter mAdapter;
private TaxiFragment mTaxiFragment;
private boolean isUpwardSliding = false;
public static TaxiReserveOrdersFragment newInstance(Activity activity, TaxiFragment taxiFragment){
Bundle args = new Bundle();
TaxiReserveOrdersFragment fragment = new TaxiReserveOrdersFragment();
fragment.setArguments( args );
fragment.mTaxiFragment = taxiFragment;
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_reserve_orders;
}
@Override
protected void initViews(View view) {
mRecyclerView = view.findViewById(R.id.order_to_be_served_rv);
mNodataTv = view.findViewById(R.id.no_order_data_tv);
mNoDataView = view.findViewById(R.id.no_order_data_view);
mNodataTv.setText("暂无待服务订单");
mBootRefreshNoDataView = view.findViewById(R.id.list_boot_refresh_no_data_view);
mBootRefreshNoDataView.setVisibility(View.GONE);
mAdapter = new ToBeServedOrdersAdapter(getActivity(),mDatas);
mRecyclerView.setLayoutManager(new LinearLayoutManager(getParentFragment().getActivity()));
mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
@Override
public void onScrollStateChanged(@NonNull RecyclerView recyclerView, int newState) {
RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
//不滑动
if (manager instanceof LinearLayoutManager && newState == SCROLL_STATE_IDLE){
LinearLayoutManager linearLayoutManager = (LinearLayoutManager) manager;
int lastItemPosition = linearLayoutManager.findLastCompletelyVisibleItemPosition();
int itemCount = manager.getItemCount();
if ((lastItemPosition == itemCount-1) && !isUpwardSliding){
//显示没有更多数据
mBootRefreshNoDataView.setVisibility(View.VISIBLE);
}
}
}
@Override
public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
super.onScrolled(recyclerView, dx, dy);
isUpwardSliding = dy > 0;
}
});
mRecyclerView.setAdapter(mAdapter);
}
public void onOrdersWaitServiceChanged(List<OrderQueryRespBean.Result> waitServiceList){//待服务订单展示
if (waitServiceList.size() == 0){
showNoDataTip();
return;
}
mNoDataView.setVisibility(View.GONE);
mRecyclerView.setVisibility(View.VISIBLE);
mDatas.clear();
mDatas.addAll(waitServiceList);
mAdapter.notifyDataSetChanged();
}
private void showNoDataTip() {
mBootRefreshNoDataView.setVisibility(View.GONE);
mNoDataView.setVisibility(View.VISIBLE);
mRecyclerView.setVisibility(View.GONE);
}
class ToBeServedOrdersAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder>{
private List<OrderQueryRespBean.Result> datas;
private Context context;
public ToBeServedOrdersAdapter(Context context, List<OrderQueryRespBean.Result> datas){
this.datas = datas;
this.context = context;
}
@NonNull
@Override
public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
View view = LayoutInflater.from(context).inflate(R.layout.taxi_order_reserve_item,parent,false);
ToBeServedOrdersViewHolder viewHolder = new ToBeServedOrdersViewHolder(view);
return viewHolder;
}
@Override
public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
if (datas != null && datas.size() >0 ){
ToBeServedOrdersViewHolder viewHolder = (ToBeServedOrdersViewHolder)holder;
OrderQueryRespBean.Result order = datas.get(position);
Calendar calendar = DateTimeUtil.formatLongToCalendar(order.bookingTime);
if (DateTimeUtil.compareDateIsCurrentDay(calendar)){
viewHolder.orderTime.setText("用车时间：今天"+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.HH_mm));
}else {
viewHolder.orderTime.setText("用车时间："+ DateTimeUtil.formatCalendarToString(calendar, DateTimeUtil.MM_dd_HH_mm));
}
viewHolder.orderCancel.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new TaxiOrderCancelDialog(mTaxiFragment,context,order.orderNo,1).show();
}
});
viewHolder.startStation.setText(order.startSiteAddr);
viewHolder.endStation.setText(order.endSiteAddr);
if (position == mDatas.size() -1){
viewHolder.deliverLine.setVisibility(View.GONE);
}
}
}
@Override
public int getItemCount() {
return datas.size();
}
}
class ToBeServedOrdersViewHolder extends RecyclerView.ViewHolder{
TextView orderTime;
ImageView orderCancel;
TextView startStation;
TextView endStation;
View deliverLine;
public ToBeServedOrdersViewHolder(@NonNull View itemView) {
super(itemView);
orderTime = itemView.findViewById(R.id.to_be_order_time);
orderCancel = itemView.findViewById(R.id.to_be_order_cancel_iv);
startStation = itemView.findViewById(R.id.base_start_station);
endStation = itemView.findViewById(R.id.base_end_station);
deliverLine = itemView.findViewById(R.id.to_be_order_divider);
}
}
public void onOrderCancelDone(String orderNo){
ToastUtils.showShort("订单取消成功");
for (int i=0; i< mDatas.size();i++){
OrderQueryRespBean.Result result = mDatas.get(i);
if (orderNo.equals(result.orderNo)){
mDatas.remove(i);
mAdapter.notifyDataSetChanged();
break;
}
}
}
@Override
public void onDestroy() {
super.onDestroy();
mTaxiFragment = null;
}
}

113
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiRottingNaviFragment.java
View File

@@ -1,113 +0,0 @@
package com.mogo.och.taxi.ui;
import android.os.Bundle;
import androidx.annotation.NonNull;
import com.amap.api.maps.model.LatLng;
import com.mogo.commons.mvp.MvpFragment;
import com.mogo.eagle.core.data.map.MogoLocation;
import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.presenter.NaviPresenter;
import java.util.List;
/**
* @author: wangmingjun
* @date: 2021/11/30
*/
public class TaxiRottingNaviFragment extends MvpFragment<TaxiRottingNaviFragment, NaviPresenter> {
private final String TAG = TaxiRottingNaviFragment.class.getSimpleName();
private TaxiMapDirectionView mMapDirectionView;
public static TaxiRottingNaviFragment newInstance() {
Bundle args = new Bundle();
TaxiRottingNaviFragment fragment = new TaxiRottingNaviFragment();
fragment.setArguments(args);
return fragment;
}
@Override
protected int getLayoutId() {
return R.layout.taxi_rotting_navi_view;
}
@Override
public String getTagName() {
return TAG;
}
@Override
protected void initViews() {
}
@Override
protected void initViews(Bundle savedInstanceState) {
super.initViews(savedInstanceState);
mMapDirectionView = mRootView.findViewById(R.id.rotting_navi_view);
mMapDirectionView.onCreateView(savedInstanceState);
}
@Override
public void onResume() {
super.onResume();
mMapDirectionView.onResume();
}
@Override
public void onPause() {
super.onPause();
mMapDirectionView.onPause();
}
@Override
public void onDestroy() {
super.onDestroy();
if (mMapDirectionView != null){
mMapDirectionView.onDestroy();
}
}
@NonNull
@Override
protected NaviPresenter createPresenter() {
return new NaviPresenter(this);
}
public void routeResult(List<LatLng> routeArrivied, List<LatLng> routeArriving, MogoLocation location){
if ((routeArrivied.size()+routeArriving.size()) > 0) {
drawablePolylineByRoute(routeArrivied,routeArriving,location);
} else {
clearPolyline();
}
}
public void setLineMarker(LatLng startStation, LatLng endStation){
if (startStation!=null&&endStation!=null) {
if (mMapDirectionView != null) {
mMapDirectionView.setStartMarkAndEndMark(startStation,endStation);
UiThreadHandler.post(() -> mMapDirectionView.setLineMarker());
}
} else {
clearPolyline();
}
}
public void drawablePolylineByRoute(List<LatLng> routeArrivied, List<LatLng> routeArriving, MogoLocation location){
if (mMapDirectionView != null){
mMapDirectionView.setCoordinatesLatLng(routeArrivied,routeArriving,location);
UiThreadHandler.post(() -> mMapDirectionView.drawablePolyline());
}
}
private void clearPolyline() {
if (mMapDirectionView != null) {
UiThreadHandler.post(() -> mMapDirectionView.clearPolyline());
}
}
}

233
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/TaxiServerOrdersFragment.java
View File

@@ -1,233 +0,0 @@
package com.mogo.och.taxi.ui;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
import android.graphics.Color;
import android.graphics.Typeface;
import android.os.Build;
import android.os.Bundle;
import android.util.TypedValue;
import android.view.View;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;
import androidx.fragment.app.FragmentTransaction;
import androidx.viewpager.widget.ViewPager;
import com.google.android.material.tabs.TabLayout;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.och.taxi.R;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.data.taxi.OrderQueryRouteInfoRespBean;
import java.util.ArrayList;
import java.util.List;
import me.jessyan.autosize.utils.AutoSizeUtils;
/**
* @author congtaowang
* @since 2021/1/18
*
* 网约车-出租车UI
*/
public class TaxiServerOrdersFragment extends BaseTaxiUIFragment {
public static final String TAG = "TaxiFragment";
public static TaxiServerOrdersFragment newInstance() {
Bundle args = new Bundle();
TaxiServerOrdersFragment fragment = new TaxiServerOrdersFragment();
fragment.setArguments( args );
return fragment;
}
private FragmentTransaction mFragmentTransaction;
private TabLayout mTaxiOrderTab;
private TextView mWaitOrderSum;
private ViewPager mTaxiOrderPager;
private String[] mTabTitles = {"进行中","待服务"};
private List<Fragment> fragments = new ArrayList<>();
private TaxiBeingServerdOrdersFragment beingServerdOrdersFragment = null;
private TaxiReserveOrdersFragment reserveOrdersFragment = null;
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
protected int getLayoutId() {
return R.layout.taxi_server_orders_panel;
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
protected void initViews(View view) {
initOrderTab(view);
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private void initOrderTab(View view) {
mWaitOrderSum = view.findViewById(R.id.wait_order_num);
mTaxiOrderTab = view.findViewById(R.id.module_och_taxi_tab);
mTaxiOrderPager = view.findViewById(R.id.module_och_taxi_view_pager);
for (int i= 0;i < mTabTitles.length; i++){
TabLayout.Tab tab = mTaxiOrderTab.newTab();
tab.view.setBackgroundColor(Color.parseColor("#00000000"));
TextView tabView = (TextView) View.inflate(getActivity(),R.layout.taxi_tab_item_custom,null);
tabView.setText(mTabTitles[i]);
tabView.setHeight(AutoSizeUtils.dp2px(getContext(),115));
tab.setCustomView(tabView);
if (0 == i){
mTaxiOrderTab.addTab(tab,true);
changeTabLayoutTabUI(tab,true);
beingServerdOrdersFragment = TaxiBeingServerdOrdersFragment.newInstance(getActivity(),(TaxiFragment) getParentFragment());
fragments.add(beingServerdOrdersFragment);
}else if (1 == i){
mTaxiOrderTab.addTab(tab);
changeTabLayoutTabUI(tab,false);
reserveOrdersFragment = TaxiReserveOrdersFragment.newInstance(getActivity(),(TaxiFragment) getParentFragment());
fragments.add(reserveOrdersFragment);
}
}
CallerLogger.d(M_TAXI + TAG,"activity="+getActivity());
mTaxiOrderTab.addOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onTabSelected(TabLayout.Tab tab) {
mTaxiOrderPager.setCurrentItem(tab.getPosition());
changeTabLayoutTabUI(tab,true);
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@Override
public void onTabUnselected(TabLayout.Tab tab) {
changeTabLayoutTabUI(tab,false);
}
@Override
public void onTabReselected(TabLayout.Tab tab) {
}
});
mTaxiOrderPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}
@Override
public void onPageSelected(int position) {
mTaxiOrderTab.getTabAt(position).select();
}
@Override
public void onPageScrollStateChanged(int state) {
}
});
mTaxiOrderPager.setAdapter(new OrdersFragmentAdapter(getChildFragmentManager(),FragmentPagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT));
}
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
private void changeTabLayoutTabUI(TabLayout.Tab tab, boolean isSelected){
TextView textView = (TextView) tab.getCustomView().findViewById(R.id.tab_title);
if (isSelected){
textView.setBackground(getActivity().getDrawable(R.drawable.taxi_driver_tab_item_bg));
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX,AutoSizeUtils.dp2px(getContext(),40));
CallerLogger.d(M_TAXI + TAG,"SelectTv = "+ textView.getText());
textView.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
textView.setTextColor(Color.parseColor("#FFFFFF"));
}else {
textView.setBackground(null);
textView.setTextSize(TypedValue.COMPLEX_UNIT_PX,AutoSizeUtils.dp2px(getContext(),36));
CallerLogger.d(M_TAXI + TAG,"unSelectTv = "+ textView.getText());
textView.setTypeface(Typeface.defaultFromStyle(Typeface.NORMAL));
textView.setTextColor(Color.parseColor("#CCD4F5"));
}
}
class OrdersFragmentAdapter extends FragmentPagerAdapter{
private FragmentManager fragmentManager;
public OrdersFragmentAdapter(@NonNull FragmentManager fm, int behavior) {
super(fm, behavior);
this.fragmentManager = fm;
}
@NonNull
@Override
public Fragment getItem(int position) {
CallerLogger.d( M_TAXI + TAG, "getItem="+position);
return fragments.get(position);
}
@Override
public int getCount() {
return fragments.size();
}
@Nullable
@Override
public CharSequence getPageTitle(int position) {
CallerLogger.d( M_TAXI + TAG, "getPageTitle="+position);
return mTabTitles[position];
}
}
@Override
public void onDestroy() {
super.onDestroy();
beingServerdOrdersFragment = null;
reserveOrdersFragment = null;
}
@RequiresApi(api = Build.VERSION_CODES.P)
public void updateCurrentOrderStatusChanged(OrderQueryRespBean.Result order){
if (beingServerdOrdersFragment != null){
mTaxiOrderTab.getTabAt(0).select();
beingServerdOrdersFragment.updateCurrentOrderStatusChanged(order);
}
}
public void onOrdersWaitServiceChanged(List<OrderQueryRespBean.Result> waitServiceList){
if (waitServiceList.size() == 0){
mWaitOrderSum.setVisibility(View.GONE);
}else {
mWaitOrderSum.setText(String.valueOf(waitServiceList.size()));
mWaitOrderSum.setVisibility(View.VISIBLE);
}
if (null == reserveOrdersFragment) return;
reserveOrdersFragment.onOrdersWaitServiceChanged(waitServiceList);
}
public void onOrderCancelDone(String orderNo){
if (null == reserveOrdersFragment) return;
reserveOrdersFragment.onOrderCancelDone(orderNo);
}
public void onCurrentOrderCancelDone(){
if (null == beingServerdOrdersFragment) return;
beingServerdOrdersFragment.onCurrentOrderCancelDone();
}
public void onCurrentOrderDistToEndChanged(long meters, long timeInSecond){
if (null == beingServerdOrdersFragment) return;
beingServerdOrdersFragment.updateDistanceAndTime(meters,timeInSecond);
}
public void onCurrentOrderRouteInfoGot(OrderQueryRouteInfoRespBean.Result routeInfo){
if (null == beingServerdOrdersFragment) return;
beingServerdOrdersFragment.onCurrentOrderRouteInfoGot(routeInfo);
}
public void updateOrderBottomBtnUI() {
if (null == beingServerdOrdersFragment) return;
beingServerdOrdersFragment.updateOrderBottomBtnUI();
}
public void onNaviToEndAmap(boolean isShow){
if (null == beingServerdOrdersFragment) return;
beingServerdOrdersFragment.onNaviToEndAmap(isShow);
}
}

54
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/ui/base/AvoidLeakDialog.java
View File

@@ -1,54 +0,0 @@
package com.mogo.och.taxi.ui.base;
import android.app.Dialog;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.DialogFragment;
import java.lang.ref.WeakReference;
/**
* @author: wangmingjun
* @date: 2022/9/1
*/
public class AvoidLeakDialog extends Dialog {
private WeakReference<DialogFragment> hostFragmentReference;
public void setHostFragmentReference(DialogFragment hostFragment) {
this.hostFragmentReference = new WeakReference<>(hostFragment);
}
public AvoidLeakDialog(@NonNull Context context) {
super(context);
}
public AvoidLeakDialog(@NonNull Context context, int themeResId) {
super(context, themeResId);
}
protected AvoidLeakDialog(@NonNull Context context, boolean cancelable, @Nullable OnCancelListener cancelListener) {
super(context, cancelable, cancelListener);
}
@Override
public void setOnCancelListener(@Nullable OnCancelListener listener) {
}
@Override
public void setOnDismissListener(@Nullable OnDismissListener listener) {
}
@Override
public void setOnShowListener(@Nullable OnShowListener listener) {
}
@Override
public void dismiss() {
super.dismiss();
if (null != hostFragmentReference && null != hostFragmentReference.get()) {
hostFragmentReference.get().dismissAllowingStateLoss();
}
}
}

22
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/utils/OrderUtil.java
View File

@@ -1,22 +0,0 @@
package com.mogo.och.taxi.utils;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import java.util.Arrays;
import java.util.List;
/**
* Created on 2021/9/11
*/
public class OrderUtil {
// 判断两个list中的订单是否相同：依据orderId
public static boolean haveSameOrders(List<OrderQueryRespBean.Result> list1,
List<OrderQueryRespBean.Result> list2) {
OrderQueryRespBean.Result[] arr1 = list1.toArray(new OrderQueryRespBean.Result[]{});
OrderQueryRespBean.Result[] arr2 = list2.toArray(new OrderQueryRespBean.Result[]{});
Arrays.sort(arr1);
Arrays.sort(arr1);
return Arrays.equals(arr1,arr2);
}
}

46
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/utils/TPRouteDataTestUtils.java
View File

File diff suppressed because one or more lines are too long

40
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/utils/TaxiAnalyticsManager.kt
View File

@@ -1,40 +0,0 @@
package com.mogo.och.taxi.utils
import com.mogo.och.common.module.manager.autopilot.autopilot.IOchEventKey
/**
* OCH Taxi埋点工具
*
* Created on 2022/3/24
*/
object TaxiAnalyticsManager : IOchEventKey {
// 埋点key：开启自动驾驶前已识别的异常，会导致无法开启自驾
const val EVENT_KEY_AP_UNABLE_START_REASON = "event_key_och_taxi_ap_unable_start_reason"
// 埋点key：接管后点击'自动驾驶'按钮启动
const val EVENT_KEY_RESTART_AUTOPILOT = "event_key_och_taxi_restart_autopilot"
// 埋点key：开始服务开启自动驾驶（成功/失败）
const val EVENT_KEY_START_SERVICE = "event_key_och_taxi_start_service"
// 埋点key：点击启动自驾
private const val EVENT_KEY_CLICK_START_AUTOPILOT = "event_key_och_taxi_click_start_autopilot"
override fun getEventKeyStartService(): String {
return EVENT_KEY_START_SERVICE
}
override fun getEventKeyRestartService(): String {
return EVENT_KEY_RESTART_AUTOPILOT
}
override fun getEventKeyApUnableStartReason(): String {
return EVENT_KEY_AP_UNABLE_START_REASON
}
override fun getEventKeyClickStartAutopilot(): String {
return EVENT_KEY_CLICK_START_AUTOPILOT
}
}

61
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/utils/TaxiMapAssetStyleUtil.java
View File

@@ -1,61 +0,0 @@
package com.mogo.och.taxi.utils;
import android.content.Context;
import java.io.IOException;
import java.io.InputStream;
/**
* @author donghongyu
* @date 12/18/20 5:37 PM
*/
public class TaxiMapAssetStyleUtil {
public static byte[] getAssetsStyle(Context context,String fileName) {
byte[] buffer1 = null;
InputStream is1 = null;
try {
is1 = context.getResources().getAssets().open(fileName); //eg. over_view_style.data
int lenght1 = is1.available();
buffer1 = new byte[lenght1];
is1.read(buffer1);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (is1 != null) {
is1.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return buffer1;
}
public static byte[] getAssetsExtraStyle(Context context, String fileName) {
byte[] buffer1 = null;
InputStream is1 = null;
try {
is1 = context.getResources().getAssets().open(fileName); //eg. over_view_style_extra.data
int lenght1 = is1.available();
buffer1 = new byte[lenght1];
is1.read(buffer1);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (is1 != null) {
is1.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return buffer1;
}
}

205
OCH/taxi/driver/src/main/java/com/mogo/och/taxi/utils/TaxiTrajectoryManager.java
View File

@@ -1,205 +0,0 @@
package com.mogo.och.taxi.utils;
import androidx.annotation.Nullable;
import com.mogo.eagle.core.data.autopilot.AutopilotControlParameters;
import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotControlManager;
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.eagle.core.utilcode.util.GsonUtils;
import com.mogo.och.common.module.manager.logchainanalytic.OchChainLogManager;
import com.mogo.och.taxi.bean.OrderQueryRespBean;
import com.mogo.och.taxi.constant.TaxiConst;
import com.mogo.och.common.module.biz.order.TaxiOrderStatusEnum;
import com.mogo.och.taxi.model.TaxiModel;
import java.util.concurrent.TimeUnit;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import mogo_msg.MogoReportMsg;
import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_TAXI;
/**
* Taxi轨迹管理：给MEC下发用于轨迹下载的信息
* Created on 2022/6/22
*/
public class TaxiTrajectoryManager {
private static final String TAG = TaxiTrajectoryManager.class.getSimpleName();
private static final class SingletonHolder {
private static final TaxiTrajectoryManager INSTANCE = new TaxiTrajectoryManager();
}
public static TaxiTrajectoryManager getInstance() {
return TaxiTrajectoryManager.SingletonHolder.INSTANCE;
}
private AutopilotControlParameters.AutoPilotLine mAutoPilotLine = null;
private Disposable mSendReqDisposable = null;
private String mPrevOrderNo = "";
public TaxiTrajectoryManager() {
mAutoPilotLine = new AutopilotControlParameters.AutoPilotLine(-1, "",
"", "", "", "", 0, "",
"", "", "", "", 0);
}
/**
* 同步订单信息
*/
public void syncTrajectoryInfo() {
OrderQueryRespBean.Result orderInfo = TaxiModel.getInstance().getCurrentOCHOrder();
if (orderInfo == null || orderInfo.orderStatus >= TaxiOrderStatusEnum.OnTheWayToEnd.getCode()) {
CallerLogger.d(M_TAXI + TAG, "syncTrajectoryInfo() stop.");
stopTrajReqLoop();
} else {
if (mPrevOrderNo.equals(orderInfo.orderNo)) {
CallerLogger.d(M_TAXI + TAG, "syncTrajectoryInfo() 重复订单.");
} else {
mPrevOrderNo = orderInfo.orderNo;
CallerLogger.d(M_TAXI + TAG, "syncTrajectoryInfo() start.");
startTrajReqLoop();
}
}
}
public void onAutopilotGuardian(@Nullable MogoReportMsg.MogoReportMessage guardianInfo, long lineId) {
onAutopilotGuardian(guardianInfo);
}
/**
* 接口MEC反馈的常规信息（MAP v2.5.0新增轨迹相关信息）
* @param guardianInfo
*/
public void onAutopilotGuardian(@Nullable MogoReportMsg.MogoReportMessage guardianInfo) {
if (guardianInfo == null || !guardianInfo.hasCode()) return;
if ("ISYS_INIT_TRAJECTORY_START".equals(guardianInfo.getCode())) {
// 1. 轨迹管理_轨迹开始下载（本地已有对应轨迹也触发）
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() 轨迹开始下载");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 轨迹开始下载", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
// ToastUtils.showShort("轨迹开始下载");
stopTrajReqLoop();
} else if ("ISYS_INIT_TRAJECTORY_SUCCESS".equals(guardianInfo.getCode())) {
// 2. 轨迹管理_轨迹下载成功（本地已有对应轨迹也触发）
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() 轨迹下载成功");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 轨迹下载成功", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
// ToastUtils.showShort("轨迹下载成功");
stopTrajReqLoop();
} else if ("ISYS_INIT_TRAJECTORY_FAILURE".equals(guardianInfo.getCode())) {
// 3. 轨迹管理_轨迹下载失败，本地无对应轨迹
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() " +
"轨迹下载失败，本地无对应轨迹");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 轨迹下载失败，本地无对应轨迹", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
// ToastUtils.showShort("轨迹下载失败，本地无对应轨迹");
} else if ("ISYS_INIT_TRAJECTORY_WARNING".equals(guardianInfo.getCode())) {
// 4. 轨迹管理_轨迹下载失败，本地有对应轨迹，认为成功
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() " +
"轨迹下载失败，本地有对应轨迹，认为成功");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 轨迹下载失败，本地有对应轨迹，认为成功", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
// ToastUtils.showShort("轨迹下载失败，本地有对应轨迹，认为成功");
} else if ("ISYS_INIT_TRAJECTORY_TIMEOUT".equals(guardianInfo.getCode())) {
// 5. 轨迹管理_轨迹下载超时
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() 轨迹下载超时");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 轨迹下载超时", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
// ToastUtils.showShort("轨迹下载超时");
} else if ("ISSM_FUNC_AUTO_PILOT_READY".equals(guardianInfo.getCode())) {
// 收到ssm的自动驾驶变为ready，再次下发轨迹下载.解决：域控重启，或者102域控启动太早，107节点初始化未完成导致的轨迹未进行下载。
CallerLogger.d(M_TAXI + TAG, "onAutopilotGuardian() ssm ready，再次发起下载");
OchChainLogManager.writeChainLog("轨迹监控","onAutopilotGuardian() 再次发起下载", true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
syncTrajectoryInfo();
}
}
private void setupAutoPilotLine() {
OrderQueryRespBean.Result order = TaxiModel.getInstance().getCurrentOCHOrder();
if (order == null) {
CallerLogger.e(M_TAXI + TAG,
"setupAutoPilotLine(): orderInfo is null.");
return;
} else {
if (mAutoPilotLine == null) {
mAutoPilotLine = new AutopilotControlParameters.AutoPilotLine(order.lineId, order.lineName,
order.csvFileUrl, order.csvFileMd5, order.txtFileUrl, order.txtFileMd5,
order.contrailSaveTime, order.carModel,
order.csvFileUrlDPQP, order.csvFileMd5DPQP, order.txtFileUrlDPQP, order.txtFileMd5DPQP,
order.contrailSaveTimeDPQP);
} else {
mAutoPilotLine.setLineId(order.lineId);
mAutoPilotLine.setLineName(order.lineName);
mAutoPilotLine.setTrajUrl(order.csvFileUrl);
mAutoPilotLine.setTrajMd5(order.csvFileMd5);
mAutoPilotLine.setStopUrl(order.txtFileUrl);
mAutoPilotLine.setStopMd5(order.txtFileMd5);
mAutoPilotLine.setTimestamp(order.contrailSaveTime);
mAutoPilotLine.setVehicleModel(order.carModel);
mAutoPilotLine.setTrajUrl_dpqp(order.csvFileUrlDPQP);
mAutoPilotLine.setTrajMd5_dpqp(order.csvFileMd5DPQP);
mAutoPilotLine.setStopUrl_dpqp(order.txtFileUrlDPQP);
mAutoPilotLine.setStopMd5_dpqp(order.txtFileMd5DPQP);
mAutoPilotLine.setTimestamp_dpqp(order.contrailSaveTimeDPQP);
}
}
}
private void clearAutoPilotLine() {
if (mAutoPilotLine == null) return;
mAutoPilotLine.setLineId(-1);
mAutoPilotLine.setLineName("");
mAutoPilotLine.setTrajUrl("");
mAutoPilotLine.setTrajMd5("");
mAutoPilotLine.setStopUrl("");
mAutoPilotLine.setStopMd5("");
mAutoPilotLine.setTimestamp(0);
mAutoPilotLine.setVehicleModel("");
mAutoPilotLine.setTrajUrl_dpqp("");
mAutoPilotLine.setTrajMd5_dpqp("");
mAutoPilotLine.setStopUrl_dpqp("");
mAutoPilotLine.setStopMd5_dpqp("");
mAutoPilotLine.setTimestamp_dpqp(0);
}
private void startTrajReqLoop() {
if (mSendReqDisposable != null && !mSendReqDisposable.isDisposed()) {
return;
}
CallerLogger.d(M_TAXI + TAG, "startTrajReqLoop()");
setupAutoPilotLine();
mSendReqDisposable = Observable.interval(TaxiConst.LOOP_DELAY,
TaxiConst.LOOP_PERIOD_10S, TimeUnit.MILLISECONDS)
.map((aLong -> aLong + 1))
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(aLong -> {
if (aLong > TaxiConst.LOOP_SEND_TRAJ_TIMES) {
mPrevOrderNo = ""; //重发超时后将mPrevOrderNo置空，这样订单进入下个状态时还可以重发
stopTrajReqLoop();
return;
}
CallerLogger.d(M_TAXI + TAG, "loop sendTrajectoryReq: " + aLong);
sendTrajectoryReq();
});
}
private void stopTrajReqLoop() {
if (mSendReqDisposable != null) {
CallerLogger.d(M_TAXI + TAG, "stopTrajReqLoop()");
mSendReqDisposable.dispose();
mSendReqDisposable = null;
clearAutoPilotLine();
}
}
private void sendTrajectoryReq() {
if (mAutoPilotLine == null) {
CallerLogger.e(M_TAXI + TAG, "sendTrajectoryReq(): mAutoPilotLine is null!!!");
return;
}
OchChainLogManager.writeChainLog("轨迹监控","sendTrajectoryReq() 下发轨迹 轨迹id"+mAutoPilotLine.getLineId(), true, OchChainLogManager.EVENT_KEY_INFE_WITH_TRAJECTORY);
CallerAutoPilotControlManager.INSTANCE.sendTrajectoryDownloadReq(mAutoPilotLine);
CallerLogger.d(M_TAXI + TAG, "sendTrajectoryReq(): "
+ GsonUtils.toJson(mAutoPilotLine));
}
}

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00001.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 10 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00002.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00003.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 35 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00004.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 49 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00005.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 49 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00006.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 49 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00007.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00008.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00009.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00010.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00011.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 55 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00012.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00013.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00014.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00015.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 53 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00016.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 54 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00017.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00018.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00019.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00020.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00021.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 55 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00022.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00023.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00024.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00025.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 55 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00026.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00027.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 56 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00028.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00029.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 53 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00030.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 53 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00031.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 54 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00032.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 49 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00033.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00034.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

BIN
OCH/taxi/driver/src/main/res/ani/drawable-nodpi/heart_00035.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 52 KiB

Some files were not shown because too many files have changed in this diff Show More