Merge branch 'dev_robotaxi-d_231205_6.2.6' into dev_robotaxi-d_231218_6.2.6

# Conflicts:
#	OCH/bus/passenger/src/jinlvvan/java/com/mogo/och/bus/passenger/MogoOCHBusPassenger.java

OCH/shuttle/passenger/src/main/java/com/mogo/och/bus/passenger/IMogoOCH.java

@@ -1,22 +0,0 @@
-package com.mogo.och.bus.passenger;
-
-import androidx.annotation.IdRes;
-import androidx.fragment.app.FragmentActivity;
-
-import com.mogo.eagle.core.function.api.base.IMoGoFunctionProvider;
-
-/**
- * 网约车抽象接口
- *
- * Created on 2022/3/29
- */
-interface IMogoOCH extends IMoGoFunctionProvider {
-
-    /**
-     * 初始化网约车容器
-     *
-     * @param activity
-     * @param containerId 容器ID
-     */
-    void createCoverage(FragmentActivity activity, @IdRes int containerId);
-}

OCH/shuttle/passenger/src/main/java/com/mogo/och/bus/passenger/utils/DimenUtil.kt

@@ -1,13 +0,0 @@
-package com.mogo.och.bus.passenger.utils
-
-import android.content.res.Resources
-
-/**
- * @author: wangmingjun
- * @date: 2022/1/21
- */
-object DimenUtil{
-    fun dp2px(value:Float):Float{
-        return  (0.5f + value * Resources.getSystem().displayMetrics.density)
-    }
-}

OCH/shuttle/passenger/src/main/java/com/mogo/och/shuttle/passenger/MogoOCHShuttlePassenger.kt

@@ -0,0 +1,105 @@
+package com.mogo.och.shuttle.passenger
+
+import android.content.Context
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import com.alibaba.android.arouter.facade.annotation.Route
+import com.mogo.eagle.core.data.config.FunctionBuildConfig
+import com.mogo.eagle.core.function.api.base.IMoGoFunctionProvider
+import com.mogo.eagle.core.function.call.setting.CallerMoGoUiSettingManager.stepInDayMode
+import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.eagle.core.utilcode.util.MultiDisplayUtils
+import com.mogo.och.shuttle.passenger.constant.BusPassengerConst
+import com.mogo.och.common.module.wigets.video.VideoPlayerActivity
+import com.mogo.och.shuttle.passenger.ui.BusPassengerRouteFragment
+import com.mogo.och.shuttle.passenger.ui.PM2BaseFragment
+
+/**
+ * 网约车-Bus-乘客端
+ *
+ * Created on 2022/3/29
+ */
+@Route(path = BusPassengerConst.PATH)
+class MogoOCHShuttlePassenger : IMoGoFunctionProvider {
+    private var mActivity: FragmentActivity? = null
+    private var mContainerId = 0
+    private var mPM2Fragment: Fragment? = null
+
+    override fun createCoverage(activity: FragmentActivity?, containerId: Int?): Fragment? {
+        mActivity = activity
+        mContainerId = containerId!!
+        showFragment()
+        if (AppIdentityModeUtils.isJL(FunctionBuildConfig.appIdentityMode)) {
+            mActivity?.let {
+                MultiDisplayUtils.startActWithSecond(it, VideoPlayerActivity::class.java)
+            }
+        }
+        return null
+    }
+
+    override val functionName: String
+        get() = "och-bus-passenger-m2"
+
+    override fun onDestroy() {
+        // 若不调用finish, 设置中打开关闭UITouch,会造成och fragment 重叠
+        mActivity?.finish()
+    }
+
+    override fun init(context: Context) {
+    }
+
+    /**
+     * 进入鹰眼模式，设置手势缩放地图失效
+     */
+    private fun stepIntoVrMode() {
+        d(SceneConstant.M_TAXI_P + TAG, "进入vr模式")
+        stepInDayMode() //白天模式 状态栏字体颜色变黑
+    }
+
+    private fun showFragment() {
+        val supportFragmentManager: FragmentManager? = mActivity?.supportFragmentManager
+        if (mPM2Fragment == null) {
+
+            d(SceneConstant.M_TAXI_P + TAG, "准备add fragment======")
+
+            val fragmentByTag: Fragment? = supportFragmentManager?.findFragmentByTag(PM2BaseFragment.TAG)
+
+            mPM2Fragment = if (fragmentByTag is Fragment){
+                fragmentByTag
+            }else{
+                if (AppIdentityModeUtils.isM2(FunctionBuildConfig.appIdentityMode)) {
+                    PM2BaseFragment()
+                }else if (AppIdentityModeUtils.isJL(FunctionBuildConfig.appIdentityMode)) {
+                    BusPassengerRouteFragment()
+                }else{
+                    BusPassengerRouteFragment()
+                }
+
+            }
+
+            if (!mPM2Fragment?.isAdded!!){
+                supportFragmentManager?.beginTransaction()
+                    ?.add(mContainerId, mPM2Fragment!!, PM2BaseFragment.TAG)?.commitAllowingStateLoss()
+            }
+            return
+        }
+        d(SceneConstant.M_TAXI_P + TAG, "准备show fragment")
+        supportFragmentManager?.beginTransaction()?.show(mPM2Fragment!!)
+            ?.commitAllowingStateLoss()
+    }
+
+    private fun hideFragment() {
+        if (mPM2Fragment != null) {
+            mActivity?.supportFragmentManager?.beginTransaction()?.hide(mPM2Fragment!!)
+                ?.commitAllowingStateLoss()
+        }
+    }
+
+    companion object {
+        private val TAG = MogoOCHShuttlePassenger::class.java.simpleName
+    }
+
+}

OCH/shuttle/passenger/src/main/java/com/mogo/och/shuttle/passenger/constant/BusPassengerConst.kt

@@ -1,6 +1,4 @@
-package com.mogo.och.bus.passenger.constant
-
-import com.mogo.commons.debug.DebugConfig
+package com.mogo.och.shuttle.passenger.constant
 
 /**
  * Created on 2021/12/6

OCH/shuttle/passenger/src/main/java/com/mogo/och/shuttle/passenger/utils/BusPassengerMapAssetStyleUtil.java

@@ -1,4 +1,4 @@
-package com.mogo.och.bus.passenger.utils;
+package com.mogo.och.shuttle.passenger.utils;
 
 
 import android.content.Context;

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/adapter/BusPassengerLineStationsAdapter.java

@@ -0,0 +1,140 @@
+package com.mogo.och.shuttle.passenger.adapter;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.mogo.och.shuttle.passenger.R;
+import com.mogo.och.common.module.utils.BlinkAnimationUtil;
+import com.mogo.och.common.module.wigets.MarqueeTextView;
+import com.mogo.och.data.bean.BusStationBean;
+
+import java.util.List;
+
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.STATION_STATUS_ARRIVING;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.STATION_STATUS_LEAVING;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.STATION_STATUS_STOPPED;
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/6
+ */
+public class BusPassengerLineStationsAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+
+    private Context mContext;
+    private List<BusStationBean> mStations;
+
+    public BusPassengerLineStationsAdapter(Context context, List<BusStationBean> stations){
+         this.mContext = context;
+         this.mStations = stations;
+    }
+
+    @NonNull
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        View view = LayoutInflater.from(mContext).inflate(R.layout.shuttle_p_jl_stations_common_item,parent,false);
+        StationViewHolder viewHolder = new StationViewHolder(view);
+        return viewHolder;
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
+        BusStationBean station = mStations.get(position);
+        StationViewHolder viewHolder = (StationViewHolder)holder;
+        viewHolder.stationName.setText(station.getName());
+        BlinkAnimationUtil.clearAnimation(viewHolder.stationCircle);
+        if (position == 0){ //第一个 起点
+            viewHolder.curArrowBg.setVisibility(View.GONE);
+            viewHolder.curArrowBottomBg.setVisibility(View.VISIBLE);
+            Log.d("onBindViewHolder" , "position0 = "+position);
+            viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_bg_start_tag_bg);
+            if (station.getDrivingStatus() == STATION_STATUS_STOPPED && !station.isLeaving()){//到达未离开
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_clock_17417B));
+                BlinkAnimationUtil.setAnimation(viewHolder.stationCircle);
+                viewHolder.stationName.setEllipsize(TextUtils.TruncateAt.MARQUEE);
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_1F82FB));
+            }else {
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_clock_992D3E5F));
+                viewHolder.stationName.setEllipsize(TextUtils.TruncateAt.END);
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_A9B6CA));
+            }
+        }else{
+            viewHolder.curArrowBg.setVisibility(View.VISIBLE);
+            viewHolder.curArrowBottomBg.setVisibility(View.VISIBLE);
+            BusStationBean preStation = mStations.get(position -1);
+            if (station.getDrivingStatus() == STATION_STATUS_LEAVING ||
+                    (station.getDrivingStatus() == STATION_STATUS_STOPPED && station.isLeaving())){ //过站
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_clock_992D3E5F));
+                viewHolder.curArrowBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_A9B6CA));
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_A9B6CA));
+                viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_point_gray);
+                viewHolder.stationName.setEllipsize(TextUtils.TruncateAt.END);
+                Log.d("onBindViewHolder" , "position 1 = "+position);
+            } else if (station.getDrivingStatus() == STATION_STATUS_STOPPED && !station.isLeaving()){//刚到站未离开的
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_clock_17417B));
+                viewHolder.curArrowBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_A9B6CA));
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_1F82FB));
+                viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_arrive_line_green);
+                if (position == mStations.size() - 1){
+                    viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_bg_end_tag_bg);
+                    viewHolder.curArrowBottomBg.setVisibility(View.GONE);
+                }
+                Log.d("onBindViewHolder" , "position2 = "+position);
+                BlinkAnimationUtil.setAnimation(viewHolder.stationCircle);
+                viewHolder.stationName.setEllipsize(TextUtils.TruncateAt.MARQUEE);
+            }else if (station.getDrivingStatus() == STATION_STATUS_ARRIVING && preStation.isLeaving()){//即将到站
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_panel_cur_station_tips_color));
+                viewHolder.curArrowBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_A9B6CA));
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_1F82FB));
+                viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_arrive_line_blue);
+                Log.d("onBindViewHolder" , "position3 = "+position);
+
+                if (position == mStations.size() - 1){
+                    viewHolder.curArrowBottomBg.setVisibility(View.GONE);
+                }
+
+            }else if (station.getDrivingStatus() == STATION_STATUS_ARRIVING &&
+                    (preStation.getDrivingStatus() == STATION_STATUS_ARRIVING
+                            || preStation.getDrivingStatus() == STATION_STATUS_STOPPED)){ //未到站的并且前面也是未到站或者刚到站的
+                viewHolder.stationName.setTextColor(mContext.getResources().getColor(R.color.shuttle_p_jl_panel_cur_station_tips_color));
+                viewHolder.curArrowBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_1F82FB));
+                viewHolder.curArrowBottomBg.setBackgroundColor(mContext.getColor(R.color.shuttle_p_jl_clock_1F82FB));
+                viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_point_blue);
+                viewHolder.stationName.setEllipsize(TextUtils.TruncateAt.END);
+
+                if (position == mStations.size() - 1){
+                    viewHolder.stationCircle.setImageResource(R.drawable.shuttle_p_jl_bg_end_tag_bg);
+                    viewHolder.curArrowBottomBg.setVisibility(View.GONE);
+                }
+                Log.d("onBindViewHolder" , "position4 = "+position);
+            }
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return mStations.size();
+    }
+}
+class StationViewHolder extends RecyclerView.ViewHolder{
+    public MarqueeTextView stationName;
+    public ImageView stationCircle;
+    public ImageView curArrowBg;
+    public ImageView curArrowBottomBg;
+    public StationViewHolder(@NonNull View itemView) {
+        super(itemView);
+        stationName = itemView.findViewById(R.id.bus_p_station);
+        stationCircle = itemView.findViewById(R.id.bus_p_circle);
+        curArrowBg = itemView.findViewById(R.id.bus_p_cur_arrow_bg);
+        curArrowBottomBg = itemView.findViewById(R.id.bus_p_cur_arrow_bottom_bg);
+    }
+}
+
+

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/bean/BusPassengerOperationStatusResponse.java

@@ -0,0 +1,21 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import com.mogo.eagle.core.data.BaseData;
+
+/**
+ * @author congtaowang
+ * @since 2021/3/22
+ *
+ * 小巴车运营状态返回参数
+ */
+public class BusPassengerOperationStatusResponse extends BaseData {
+
+    public Result data;
+
+    public static class Result {
+        private String sn; //司机屏sn
+        private String phone; //司机手机号
+        public String plateNumber; //车牌号
+        public int driverStatus;//0:已收车，1:已出车
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/bean/BusPassengerQueryLineRequest.java

@@ -0,0 +1,16 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+public
+/**
+ * @author congtaowang
+ * @since 2021/3/22
+ *
+ * 根据车机行驶线路站点信息
+ */
+class BusPassengerQueryLineRequest {
+
+    private String sn;
+    public BusPassengerQueryLineRequest(String sn) {
+        this.sn = sn;
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/bean/BusPassengerRoutesResponse.java

@@ -0,0 +1,29 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import com.mogo.eagle.core.data.BaseData;
+import com.mogo.och.data.bean.BusRoutesResult;
+
+/**
+ * 网约车小巴路线接口请求响应结果 返回的是对应司机屏的线路信息
+ *
+ * @author tongchenfei
+ */
+public class BusPassengerRoutesResponse extends BaseData {
+    private BusRoutesResult data;
+
+    public BusRoutesResult getResult() {
+        return data;
+    }
+
+    public void setResult(BusRoutesResult data) {
+        this.data = data;
+    }
+
+    @Override
+    public String toString() {
+        return "OchBusRoutesResponse{" +
+                "data=" + data +
+                '}';
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/bean/BusPassengerRoutesResult.java

@@ -0,0 +1,85 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 网约车小巴路线接口返回接口数据封装
+ *
+ * @author tongchenfei
+ */
+public class BusPassengerRoutesResult {
+    private List<BusPassengerStation> sites;
+    private int lineId;
+    private String name; //线路名称
+    private int lineType;  //线路类型，0:环形
+    private String description;
+    private int status;
+    private String runningDur; //运营时间
+    private long taskTime; //线路时间班次
+    private long writeVersion;//更新时间戳
+
+    public List<BusPassengerStation> getSites() {
+        return sites;
+    }
+
+    public int getLineId() {
+        return lineId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getLineType() {
+        return lineType;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getRunningDur() {
+        return runningDur;
+    }
+
+    public long getWriteVersion() {
+        return writeVersion;
+    }
+
+    @Override
+    public String toString() {
+        return "BusPassengerRoutesResult{" +
+                "sites=" + sites +
+                ", lineId=" + lineId +
+                ", name='" + name + '\'' +
+                ", lineType=" + lineType +
+                ", description='" + description + '\'' +
+                ", status=" + status +
+                ", writeVersion="+ writeVersion+
+                ", runningDur='" + runningDur + '\'' +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BusPassengerRoutesResult that = (BusPassengerRoutesResult) o;
+        return lineId == that.lineId
+                && lineType == that.lineType
+                && status == that.status
+                && sites.equals(that.sites)
+                && name.equals(that.name)
+                && runningDur.equals(that.runningDur);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sites, lineId, name, lineType, description, status, runningDur);
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/bean/BusPassengerStation.java

@@ -0,0 +1,173 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import java.util.Objects;
+
+/**
+ * 单个网约车小巴车站信息
+ *
+ * @author wangmingjun
+ */
+public class BusPassengerStation {
+
+    private String name;
+    private String description;
+    private String cityCode;
+    private double lon; //高精坐标
+    private double lat; //高精坐标
+    private double gcjLon; //高德坐标
+    private double gcjLat; //高德坐标
+    private int businessType; //站点类型，9:taxi，10:bus
+    private int status;
+    private int siteId;
+    private int seq;
+    private int drivingStatus;//行驶信息，0初始值；1已经过；2当前站；3未到站
+    private int ifStop = 1; // 是否需要停靠、1需要、0不需要   // TODO: 2021/10/19 原来站点里有设计是否需要停靠字段，现设计暂无，默认都需要停靠
+    private boolean leaving;
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public void setCityCode(String cityCode) {
+        this.cityCode = cityCode;
+    }
+
+    public void setLon(double lon) {
+        this.lon = lon;
+    }
+
+    public void setLat(double lat) {
+        this.lat = lat;
+    }
+
+    public void setBusinessType(int businessType) {
+        this.businessType = businessType;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public void setSiteId(int siteId) {
+        this.siteId = siteId;
+    }
+
+    public void setSeq(int seq) {
+        this.seq = seq;
+    }
+
+    public void setDrivingStatus(int drivingStatus) {
+        this.drivingStatus = drivingStatus;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public String getCityCode() {
+        return cityCode;
+    }
+
+    public double getGcjLon() {
+        return gcjLon;
+    }
+
+    public double getGcjLat() {
+        return gcjLat;
+    }
+
+    public int getBusinessType() {
+        return businessType;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public int getSiteId() {
+        return siteId;
+    }
+
+    public int getSeq() {
+        return seq;
+    }
+
+    public int getDrivingStatus() {
+        return drivingStatus;
+    }
+
+    public double getLon() {
+        return lon;
+    }
+
+    public double getLat() {
+        return lat;
+    }
+
+    public void setIfStop(int ifStop) {
+        this.ifStop = ifStop;
+    }
+
+    public int getIfStop() {
+        return ifStop;
+    }
+
+    public void setLeaving(boolean leaving) {
+        this.leaving = leaving;
+    }
+
+    public boolean isLeaving() {
+        return leaving;
+    }
+
+    @Override
+    public String toString() {
+        return "OchBusStation{" +
+                "name='" + name + '\'' +
+                ", description='" + description + '\'' +
+                ", cityCode='" + cityCode + '\'' +
+                ", lon=" + lon +
+                ", lat=" + lat +
+                ", businessType=" + businessType +
+                ", status=" + status +
+                ", siteId=" + siteId +
+                ", seq=" + seq +
+                ", drivingStatus=" + drivingStatus +
+                ", ifStop=" + ifStop +
+                ", leaving=" + leaving +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BusPassengerStation that = (BusPassengerStation) o;
+        return Double.compare(that.lon, lon) == 0
+                && Double.compare(that.lat, lat) == 0
+                && Double.compare(that.gcjLon, gcjLon) == 0
+                && Double.compare(that.gcjLat, gcjLat) == 0
+                && businessType == that.businessType
+                && status == that.status
+                && siteId == that.siteId
+                && seq == that.seq
+                && drivingStatus == that.drivingStatus
+                && ifStop == that.ifStop
+                && leaving == that.leaving
+                && Objects.equals(name, that.name)
+                && Objects.equals(cityCode, that.cityCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, description, cityCode, lon, lat, gcjLon, gcjLat, businessType, status, siteId, seq, drivingStatus, ifStop, leaving);
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassegerDriverStatusCallback.java

@@ -0,0 +1,10 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+/**
+ * @author: wangmingjun
+ * @date: 2021/10/22
+ */
+public interface IBusPassegerDriverStatusCallback {
+    void changeOperationStatus(boolean changeStatus);
+    void updatePlateNumber(String plateNumber);
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassengerADASStatusCallback.java

@@ -0,0 +1,20 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+/**
+ * Created on 2022/3/31
+ *
+ * Model->Presenter回调：ADAS相关（自动驾驶状态回调，到达终点等等）
+ */
+public interface IBusPassengerADASStatusCallback {
+    // 自动驾驶触发的已到达目的地：暂未用到
+    void onAutopilotArriveEnd();
+
+    // 自动驾驶可用状态
+    void onAutopilotEnable();
+
+    // 自动驾驶不可用状态
+    void onAutopilotDisable();
+
+    // 自动驾驶运行中
+    void onAutopilotRunning();
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassengerAutopilotPlanningCallback.java

@@ -0,0 +1,15 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+import com.amap.api.maps.model.LatLng;
+
+import java.util.List;
+
+import mogo.telematics.pad.MessagePad;
+
+/**
+ * Created on 2022/3/31
+ */
+public interface IBusPassengerAutopilotPlanningCallback {
+    void routePlanningToNextStationChanged(long meters, long timeInSecond);
+    void updateTotalDistance();
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassengerControllerStatusCallback.java

@@ -0,0 +1,15 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+import com.mogo.eagle.core.data.map.MogoLocation;
+
+/**
+ * Created on 2022/3/31
+ *
+ * Model->Presenter回调：状态控制器监听（accOn、adas ui show、voice ui show、push ui show、v2x ui show等等）
+ */
+public interface IBusPassengerControllerStatusCallback {
+    // 是否vr map模式
+    void onVRModeChanged(boolean isVRMode);
+    // 自车定位
+    void onCarLocationChanged(MogoLocation location);
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassengerMapViewCallback.java

@@ -0,0 +1,9 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/3/10
+ */
+public interface IBusPassengerMapViewCallback {
+    void onCameraChange(float bearing);
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/callback/IBusPassengerRouteLineInfoCallback.java

@@ -0,0 +1,16 @@
+package com.mogo.och.shuttle.passenger.callback;
+
+import com.mogo.och.data.bean.BusStationBean;
+
+import java.util.List;
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/6
+ */
+public interface IBusPassengerRouteLineInfoCallback {
+    void updateLineInfo(String lineName);
+    void updateStationsInfo(List<BusStationBean> stations, int currentStationIndex, boolean isArrived);
+    void showNoTaskView();
+    void hideNoTaskView();
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/model/BusPassengerModel.java

@@ -0,0 +1,670 @@
+package com.mogo.och.shuttle.passenger.model;
+
+import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_BUS_P;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.QUERY_BUS_P_STATION_DELAY;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.STATION_STATUS_STOPPED;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import android.os.Handler;
+import android.os.Message;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+
+import com.mogo.aicloud.services.socket.MogoAiCloudSocketManager;
+import com.mogo.commons.debug.DebugConfig;
+import com.mogo.commons.module.intent.IMogoIntentListener;
+import com.mogo.commons.module.intent.IntentManager;
+import com.mogo.commons.module.status.IMogoStatusChangedListener;
+import com.mogo.commons.module.status.MogoStatusManager;
+import com.mogo.eagle.core.function.api.telematic.IReceivedMsgListener;
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicListenerManager;
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicManager;
+import com.mogo.eagle.core.utilcode.mogo.logger.Logger;
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant;
+import com.mogo.eagle.core.utilcode.util.GsonUtils;
+import com.mogo.eagle.core.utilcode.util.ToastUtils;
+import com.mogo.och.shuttle.passenger.R;
+import com.mogo.och.shuttle.passenger.bean.BusPassengerOperationStatusResponse;
+import com.mogo.och.shuttle.passenger.bean.BusPassengerRoutesResponse;
+import com.mogo.och.common.module.bean.dpmsg.AppConnectMsg;
+import com.mogo.och.common.module.bean.dpmsg.BaseDPMsg;
+import com.mogo.och.common.module.bean.dpmsg.DPMsgType;
+import com.mogo.och.common.module.bean.dpmsg.TaskDetailsMsg;
+import com.mogo.och.common.module.biz.common.socketmessage.OCHSocketMessageManager;
+import com.mogo.och.common.module.biz.constant.OchCommonConst;
+import com.mogo.och.common.module.manager.distancemamager.IDistanceListener;
+import com.mogo.och.common.module.manager.distancemamager.TrajectoryAndDistanceManager;
+import com.mogo.och.common.module.utils.DateTimeUtil;
+import com.mogo.commons.module.status.StatusDescriptor;
+import com.mogo.eagle.core.data.autopilot.AutopilotStatusInfo;
+import com.mogo.eagle.core.data.config.FunctionBuildConfig;
+import com.mogo.eagle.core.data.map.MogoLocation;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoChassisLocationGCJ02Listener;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoPlanningRottingListener;
+import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager;
+import com.mogo.eagle.core.function.call.autopilot.CallerChassisLocationGCJ02ListenerManager;
+import com.mogo.eagle.core.function.call.autopilot.CallerPlanningRottingListenerManager;
+import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils;
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
+import com.mogo.eagle.core.utilcode.mogo.storage.SharedPrefsMgr;
+import com.mogo.eagle.core.utilcode.util.NetworkUtils;
+import com.mogo.och.shuttle.passenger.callback.IBusPassegerDriverStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerADASStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerAutopilotPlanningCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerControllerStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerRouteLineInfoCallback;
+import com.mogo.och.shuttle.passenger.constant.BusPassengerConst;
+import com.mogo.och.shuttle.passenger.network.BusPassengerModelLoopManager;
+import com.mogo.och.shuttle.passenger.network.BusPassengerServiceManager;
+import com.mogo.och.common.module.biz.network.OchCommonServiceCallback;
+import com.mogo.och.common.module.manager.AbnormalFactorsLoopManager;
+import com.mogo.och.common.module.utils.CoordinateCalculateRouteUtil;
+import com.mogo.och.common.module.utils.RxUtils;
+import com.mogo.och.data.bean.BusRoutesResult;
+import com.mogo.och.data.bean.BusStationBean;
+import com.mogo.och.data.bean.BusTransferData;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import io.reactivex.disposables.Disposable;
+import mogo.telematics.pad.MessagePad;
+import mogo_msg.MogoReportMsg;
+import system_master.SsmInfo;
+import system_master.SystemStatusInfo;
+
+/**
+ * Created on 2022/3/31
+ */
+public class BusPassengerModel {
+    private static final String TAG = BusPassengerModel.class.getSimpleName();
+
+    private volatile List<MogoLocation> mRoutePoints = new ArrayList<>();
+    // 1s内只接受一次轨迹
+    private volatile Disposable globalPathTruncation;
+    private static final class SingletonHolder {
+        private static final BusPassengerModel INSTANCE = new BusPassengerModel();
+    }
+
+    public static BusPassengerModel getInstance() {
+        return SingletonHolder.INSTANCE;
+    }
+
+    private Context mContext;
+    private IBusPassengerADASStatusCallback mADASStatusCallback; //Model->Presenter：自动驾驶状态相关
+    private IBusPassengerAutopilotPlanningCallback mAutopilotPlanningCallback; //Model->Presenter：自动驾驶线路规划
+    private Map<String, IBusPassengerControllerStatusCallback> mControllerStatusCallbackMap = new ConcurrentHashMap<>();
+
+    private IBusPassegerDriverStatusCallback mDriverStatusCallback; //出车收车状态
+    private IBusPassengerRouteLineInfoCallback mRouteLineInfoCallback; // bus路线信息更新
+
+    private MogoLocation  mLocation = null;
+
+    private BusRoutesResult routesResult = null;
+
+    List<BusStationBean> mStations = new ArrayList<>();
+    private int mNextStationIndex = 0;// 要到达站的index
+    private List<MogoLocation> mTwoStationsRouts = new ArrayList<>();
+    private int mPreRouteIndex = 0;
+    private int mWipePreIndex = 0;
+
+    private volatile boolean isGoingToNextStation = false;
+
+    private static final int MSG_QUERY_BUS_P_STATION = 1001;
+    private final Handler handler = new Handler(new Handler.Callback() {
+        @Override
+        public boolean handleMessage(Message msg) {
+            if ( msg.what == MSG_QUERY_BUS_P_STATION ) {
+                queryDriverOperationStatus();
+                return true;
+            }
+            return false;
+        }
+    });
+
+    private BusPassengerModel() {
+    }
+
+    public void init( Context context ) {
+        mContext = context.getApplicationContext();
+        initListeners();
+        queryDriverOperationStatus();
+        queryDriverByLocalDriver();
+        startOrStopOrderLoop(true);
+    }
+
+    private void queryDriverByLocalDriver() {
+        //本地去请求司机端
+        TaskDetailsMsg msg = new TaskDetailsMsg("task");
+
+        sendMsgToServer(GsonUtils.toJson(msg));
+    }
+
+    public void setDriverStatusCallback(IBusPassegerDriverStatusCallback callback){
+        this.mDriverStatusCallback = callback;
+    }
+
+    public void setRouteLineInfoCallback(IBusPassengerRouteLineInfoCallback callback){
+        this.mRouteLineInfoCallback = callback;
+    }
+
+    private void queryDriverOperationDelay() {
+        handler.sendEmptyMessageDelayed( MSG_QUERY_BUS_P_STATION, QUERY_BUS_P_STATION_DELAY );
+    }
+
+    private void sendMsgToServer(String msg){
+        CallerTelematicManager.INSTANCE.sendMsgToServer(
+                OchCommonConst.BUSINESS_STRING,
+                msg.getBytes()
+        );
+    }
+
+    private void queryDriverOperationStatus() {
+        BusPassengerServiceManager.queryDriverOperationStatus(mContext
+                , new OchCommonServiceCallback<BusPassengerOperationStatusResponse>() {
+                    @Override
+                    public void onSuccess(BusPassengerOperationStatusResponse data) {
+                        if (data == null || data.data == null) return;
+                        if (mDriverStatusCallback != null) {
+                            CallerLogger.d( M_BUS_P + TAG, "queryDriverOperationStatus = %s", data.data.plateNumber );
+                            mDriverStatusCallback.changeOperationStatus(data.data.driverStatus == 1);
+                            mDriverStatusCallback.updatePlateNumber(data.data.plateNumber);
+                        }
+                    }
+
+                    @Override
+                    public void onError() {
+                        if (!NetworkUtils.isConnected(mContext)) {
+                            ToastUtils.showShort(mContext.getString(R.string.network_error_tip));
+                        } else {
+                            ToastUtils.showShort(mContext.getString(R.string.request_error_tip));
+                        }
+                    }
+
+                    @Override
+                    public void onFail(int code, String msg) {
+                        //延迟3s再次查询
+                        queryDriverOperationDelay();
+                    }
+                });
+    }
+
+    public void queryDriverSiteByCoordinate(){
+        BusPassengerServiceManager.queryDriverSiteByCoordinate(mContext
+                , new OchCommonServiceCallback<BusPassengerRoutesResponse>() {
+                    @Override
+                    public void onSuccess(BusPassengerRoutesResponse data) {
+                        if ( data == null || data.getResult() == null) {
+                            CallerLogger.d( M_BUS_P + TAG, "queryDriverSiteByCoordinate = null");
+                            clearLocalRouteResult();
+                            return;
+                        }
+                        if (routesResult != null && data.getResult().equals(routesResult)){
+                            CallerLogger.d( M_BUS_P + TAG, "queryDriverSiteByCoordinate = not update");
+                            return;
+                        }
+
+                        if (routesResult != null &&
+                                routesResult.getWriteVersion() < data.getResult().getWriteVersion()){
+                            routesResult = data.getResult();
+                        }
+
+                        if (routesResult == null){
+                            routesResult = data.getResult();
+                        }
+
+                        updatePassengerRouteInfo(routesResult);
+                    }
+
+                    @Override
+                    public void onError() {
+                        CallerLogger.d( M_BUS_P + TAG, "queryDriverSiteByCoordinate = onError ="
+                                + ", sn = " +BusPassengerServiceManager.INSTANCE.getDriverAppSn());
+                        queryDriverByLocalDriver();
+                    }
+
+                    @Override
+                    public void onFail(int code, String msg) {
+                        CallerLogger.d( M_BUS_P + TAG, "queryDriverSiteByCoordinate = %s", msg
+                           + ", sn = " +BusPassengerServiceManager.INSTANCE.getDriverAppSn());
+                        if (code == 1003){
+                            queryDriverOperationDelay();
+                        }
+                        if (BusPassengerServiceManager.INSTANCE.getDriverAppSn().isEmpty()){
+                            //此处拦截是为了防止过程中乘客屏和司机端断连，拿不到司机端sn, 造成请求失败去刷新了界面
+                            return;
+                        }
+                        if (code == 1003){
+                            routesResult = null;
+                            cleanStation("queryDriverSiteByCoordinate 1003");
+                            return;
+                        }
+                        queryDriverByLocalDriver();
+                    }
+                });
+    }
+
+    private void clearLocalRouteResult() {
+        if (routesResult != null) {
+            routesResult = null;
+        }
+        mNextStationIndex = 0;
+        cleanStation("queryDriverSiteByCoordinate");
+        mRoutePoints.clear();
+        if (mRouteLineInfoCallback != null){
+            mRouteLineInfoCallback.showNoTaskView();
+        }
+    }
+
+    private void updatePassengerRouteInfo(BusRoutesResult result) {
+        if (result == null){
+            clearLocalRouteResult();
+            return;
+        }
+        CallerLogger.d( M_BUS_P + TAG, "queryDriverSiteByCoordinate = update");
+        routesResult = result;
+
+        if (mRouteLineInfoCallback != null){
+            mRouteLineInfoCallback.updateLineInfo(result.getName());
+            mRouteLineInfoCallback.hideNoTaskView();
+            if (result.getSites() != null){
+                List<BusStationBean> stations = result.getSites();
+                mStations.clear();
+                mStations.addAll(stations);
+                for (int i = 0; i< stations.size(); i++){
+                    BusStationBean station = stations.get(i);
+                     if (station.getDrivingStatus() == STATION_STATUS_STOPPED && station.isLeaving() && i+1 < stations.size()){
+                         Logger.d(M_BUS_P + TAG, "order =  station= leave");
+                         isGoingToNextStation = true;
+                         mRouteLineInfoCallback.updateStationsInfo(stations,i+1,false);
+                         if(mNextStationIndex != i+1){
+                             mTwoStationsRouts.clear();
+                         }
+                         mNextStationIndex = i+1;
+                         BusStationBean startStation = mStations.get(i);
+                         BusStationBean endStation = mStations.get(i+1);
+                         setTrajectoryStation(startStation, endStation, result.getLineId());
+                         return;
+                     }else if (station.getDrivingStatus() == STATION_STATUS_STOPPED && !station.isLeaving()){
+                         if (i == stations.size() - 1) {
+                             cleanStation("updatePassengerRouteInfo最后一个站点");
+                         }
+
+                         isGoingToNextStation = false;
+                         Logger.d(M_BUS_P + TAG, "order =  station= arrive");
+                         mPreRouteIndex = 0;
+                         mRouteLineInfoCallback.updateStationsInfo(stations,i,true);
+                         return;
+                     }
+                }
+            }
+        }
+
+    }
+
+    public void release() {
+        releaseListeners();
+        cleanStation("release");
+        startOrStopOrderLoop(false);
+    }
+
+    public void setMoGoAutopilotPlanningListener(IBusPassengerAutopilotPlanningCallback
+                                                         moGoAutopilotPlanningCallback) {
+        this.mAutopilotPlanningCallback = moGoAutopilotPlanningCallback;
+    }
+
+    public void setADASStatusCallback(IBusPassengerADASStatusCallback callback) {
+        this.mADASStatusCallback = callback;
+    }
+
+    public void setControllerStatusCallback(String tag, IBusPassengerControllerStatusCallback callback) {
+        if (tag == null || "".equals(tag)) return;
+
+        if (callback == null) {
+            mControllerStatusCallbackMap.remove(tag);
+            return;
+        }
+
+        mControllerStatusCallbackMap.put(tag,callback);
+
+    }
+
+    private void initListeners() {
+
+        // 2021.11.1重构自动驾驶 实现接口 IMoGoAutopilotStatusListener 注册监听 替换IMogoAdasOCHCallback接口
+        CallerAutoPilotStatusListenerManager.INSTANCE.addListener(TAG, mGoAutopilotStatusListener);
+        IntentManager.getInstance().registerIntentListener(ConnectivityManager.CONNECTIVITY_ACTION, mNetWorkIntentListener );
+        MogoStatusManager.getInstance().registerStatusChangedListener(TAG, StatusDescriptor.VR_MODE, mMogoStatusChangedListener );
+        // 定位监听
+        CallerChassisLocationGCJ02ListenerManager.INSTANCE.addListener(TAG, 10,mMapLocationListener);
+
+        //2021.11.1 自动驾驶路线规划接口
+        CallerPlanningRottingListenerManager.INSTANCE.addListener(TAG,moGoAutopilotPlanningListener);
+
+        //监听司机端消息
+        CallerTelematicListenerManager.INSTANCE.addListener(TAG,mReceivedMsgListener);
+
+        AbnormalFactorsLoopManager.INSTANCE.startLoopAbnormalFactors(mContext);
+        TrajectoryAndDistanceManager.INSTANCE.addDistanceListener(TAG, trajectoryListener);
+    }
+
+    private void releaseListeners() {
+        MogoStatusManager.getInstance().unregisterStatusChangedListener(TAG, StatusDescriptor.VR_MODE, mMogoStatusChangedListener);
+
+        // 注销定位监听
+        CallerChassisLocationGCJ02ListenerManager.INSTANCE.removeListener(TAG);
+
+        MogoAiCloudSocketManager.getInstance(mContext)
+                .unregisterLifecycleListener(10010);
+
+        CallerAutoPilotStatusListenerManager.INSTANCE.removeListener(mGoAutopilotStatusListener);
+        CallerPlanningRottingListenerManager.INSTANCE.removeListener(moGoAutopilotPlanningListener);
+
+        AbnormalFactorsLoopManager.INSTANCE.stopLoopAbnormalFactors();
+
+        CallerTelematicListenerManager.INSTANCE.removeListener(TAG);
+        CallerTelematicListenerManager.INSTANCE.removeListener(TAG);
+    }
+
+    private final IDistanceListener trajectoryListener = new IDistanceListener() {
+        @Override
+        public void stationDistanceCallback(float distance) {
+
+        }
+        @Override
+        public void distanceCallback(float distance) {
+            double lastTime  = distance / BusPassengerConst.BUS_AVERAGE_SPEED * 3.6; //秒
+            CallerLogger.d(M_BUS_P + TAG, "轨迹排查==lastSumLength = "+distance);
+            if(routesResult!=null){
+                for (BusStationBean site : routesResult.getSites()) {
+                    if (site.getDrivingStatus() == BusPassengerConst.STATION_STATUS_STOPPED && !site.isLeaving()) {
+                        return;
+                    }
+                }
+            }
+            mAutopilotPlanningCallback.routePlanningToNextStationChanged(
+                    (long)distance, (long)lastTime
+            );
+        }
+    };
+
+    private final IReceivedMsgListener mReceivedMsgListener = new IReceivedMsgListener() {
+        @Override
+        public void onDemoMode(boolean isDemoMode) {
+
+        }
+
+        @Override
+        public void onReceivedServerSn(@Nullable String sn) {
+        }
+
+        @Override
+        public void onReceivedMsg(int type, @NonNull byte[] byteArray) {
+            if (OchCommonConst.BUSINESS_STRING == type) {
+
+                BaseDPMsg baseMsg = GsonUtils.fromJson(new String(byteArray), BaseDPMsg.class);
+                Logger.d(SceneConstant.M_BUS_P + TAG, "onReceivedMsg = " + GsonUtils.toJson(baseMsg));
+
+                if (baseMsg != null && baseMsg.getType() == DPMsgType.TYPE_COMMON.getType()) {
+                    AppConnectMsg msg = GsonUtils.fromJson(new String(byteArray), AppConnectMsg.class);
+                    if (msg != null && msg.isViewShow()) { //消息盒子显示内容
+                        OCHSocketMessageManager.INSTANCE.pushAppOperationalMsgBox(
+                                DateTimeUtil.getCurrentTimeStamp(), msg.getMsg(),
+                                OCHSocketMessageManager.OPERATION_SYSTEM);
+                    }
+                } else if (baseMsg != null && baseMsg.getType() == DPMsgType.TYPE_TASK_DETAILS.getType()) {
+                    TaskDetailsMsg msg = GsonUtils.fromJson(new String(byteArray), TaskDetailsMsg.class);
+
+                    Logger.d(SceneConstant.M_BUS_P + TAG, "onReceivedMsg = " + GsonUtils.toJson(msg));
+                    if (msg == null || msg.getMsg().isEmpty()) {
+                        clearLocalRouteResult();
+                        return;
+                    }
+                    BusTransferData result = GsonUtils.fromJson(msg.getMsg(), BusTransferData.class);
+                    if (msg != null && mDriverStatusCallback != null) {
+                        mDriverStatusCallback.changeOperationStatus(result.getLoginStatus() == 1);
+                    }
+                    if (result != null) { //已司机端传来的为准
+                        routesResult = result.getRoutesResult();
+                        updatePassengerRouteInfo(routesResult);
+                    }
+                }
+            }
+        }
+    };
+
+
+    //监听网络变化，避免启动机器时无网导致无法更新订单信息
+    private final IMogoIntentListener mNetWorkIntentListener = new IMogoIntentListener() {
+        @Override
+        public void onIntentReceived( String intentStr, Intent intent ) {
+            CallerLogger.d( M_BUS_P + TAG, "onIntentReceived = %s", intentStr );
+            if ( ConnectivityManager.CONNECTIVITY_ACTION.equals( intentStr ) ) {
+                if ( NetworkUtils.isConnected( mContext ) ) {
+                    queryDriverOperationStatus();
+                }
+            }
+        }
+    };
+
+    // VR mode变更回调
+    private final IMogoStatusChangedListener mMogoStatusChangedListener = (descriptor, isTrue) -> {
+        if (StatusDescriptor.VR_MODE == descriptor) {
+            if (mControllerStatusCallbackMap.size() > 0) {
+                for (IBusPassengerControllerStatusCallback callback :mControllerStatusCallbackMap.values()){
+                    callback.onVRModeChanged(isTrue);
+                }
+            }
+        }
+    };
+
+    private final IMoGoChassisLocationGCJ02Listener mMapLocationListener = new IMoGoChassisLocationGCJ02Listener() {
+        @Override
+        public void onChassisLocationGCJ02(@Nullable MogoLocation gnssInfo) {
+            if (null == gnssInfo) return;
+            mLocation = gnssInfo;
+            for (IBusPassengerControllerStatusCallback callback :mControllerStatusCallbackMap.values()){
+                callback.onCarLocationChanged(gnssInfo);
+            }
+        }
+    };
+
+    private final IMoGoAutopilotStatusListener mGoAutopilotStatusListener = new IMoGoAutopilotStatusListener(){
+        @Override
+        public void onSystemStatus(@NonNull SsmInfo.SsmStatusInf statusInf) {
+            //IMoGoAutopilotStatusListener.super.onSystemStatus(statusInf);
+        }
+
+        @Override
+        public void onAutopilotDockerInfo(@NonNull String dockerVersion) {
+            // TODO: 2023/6/19 mingjun
+        }
+
+        @Override
+        public void onAutopilotStatusResponse(int state) {
+            if (state == IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING) {
+                //2022.7.20 自动驾驶更换成带档位的
+                if (mADASStatusCallback != null) mADASStatusCallback.onAutopilotRunning();
+            } else{
+                if (FunctionBuildConfig.isDemoMode &&
+                        mNextStationIndex>= 0 && mNextStationIndex <= mStations.size() - 1
+                        && isGoingToNextStation){
+                    Logger.d(M_BUS_P + TAG, "FunctionBuildConfig.isDemoMode is true");
+                    return;
+                }
+
+                if (state == IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_ENABLE) {
+                    mTwoStationsRouts.clear();
+                    if (mADASStatusCallback != null) mADASStatusCallback.onAutopilotEnable();
+                } else if (state == IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE) {
+                    mTwoStationsRouts.clear();
+                    if (mADASStatusCallback != null) mADASStatusCallback.onAutopilotDisable();
+                }else if (state == IMoGoAutopilotStatusListener.STATUS_PARALLEL_DRIVING){
+                    mTwoStationsRouts.clear();
+                    if (mADASStatusCallback != null) mADASStatusCallback.onAutopilotRunning();
+                }
+            }
+        }
+
+        @Override
+        public void onAutopilotRouteLineId(long lineId) {
+
+        }
+
+        @Override
+        public void onAutopilotIpcConnectStatusChanged(int status, @Nullable String reason) {
+        }
+
+        @Override
+        public void onAutopilotGuardian(@Nullable MogoReportMsg.MogoReportMessage guardianInfo) {
+
+        }
+
+        private boolean arriveAtEnd = false; //乘客app专用字段
+
+        @Override
+        public void onAutopilotSNRequest() {
+
+        }
+
+        @Override
+        public void onAutopilotArriveAtStation(@Nullable MessagePad.ArrivalNotification arrivalNotification) {
+            if (FunctionBuildConfig.isDemoMode
+                    && AppIdentityModeUtils.isPassenger(FunctionBuildConfig.appIdentityMode)) {
+                arriveAtEnd = true;
+            }
+
+            // TODO: 2022/3/31  
+            if (DebugConfig.isDebug()) {
+                // ToastUtils.showShort("到达目的地");
+            }
+            if (mADASStatusCallback != null){
+                mADASStatusCallback.onAutopilotArriveEnd();
+            }
+        }
+
+        @Override
+        public void onAutopilotStatusRespByQuery(@NonNull SystemStatusInfo.StatusInfo status) {
+
+        }
+    };
+
+    private final IMoGoPlanningRottingListener moGoAutopilotPlanningListener = new IMoGoPlanningRottingListener(){
+
+        @Override
+        public synchronized void onAutopilotRotting(@Nullable MessagePad.GlobalPathResp routeList) {
+//            CallerLogger.d(M_BUS_P + TAG, "onAutopilotRotting = "
+//                    + GsonUtil.jsonFromObject(routeList));
+            if(routeList == null){
+                return;
+            }
+            List<MessagePad.Location> routePoints = routeList.getWayPointsList();
+
+            if(globalPathTruncation!=null&&!globalPathTruncation.isDisposed()){
+                CallerLogger.d(M_BUS_P + TAG, "1s内不可以接受轨迹");
+                return;
+            }
+
+            globalPathTruncation = RxUtils.INSTANCE.createSubscribe(1_000, () -> {
+                CallerLogger.d(M_BUS_P + TAG, "可以接受轨迹");
+                return null;
+            });
+            CallerLogger.d(M_BUS_P + TAG, "接受轨迹中");
+            if (null != routePoints && routePoints.size() > 0){
+                updateRoutePoints(routePoints);
+            }
+        }
+    };
+
+    public synchronized void updateRoutePoints(List<MessagePad.Location> routePoints){
+        mRoutePoints.clear();
+        List<MogoLocation> latLngModels = CoordinateCalculateRouteUtil
+                .coordinateConverterWgsToGcjLocations(mContext,routePoints);
+        mRoutePoints.addAll(latLngModels);
+        calculateTwoStationsRoute();
+    }
+
+    private void calculateTwoStationsRoute(){
+        //找出前往站对应的轨迹点，拿出两站点的集合
+        CallerLogger.d(M_BUS_P + TAG, "mRoutePoints.size() = " + mRoutePoints.size());
+        if (mRoutePoints.size() > 0) {
+            if (mStations.size() > 1){ //两个站点及以上要计算两个站点间的轨迹路线
+                if (mNextStationIndex <= mStations.size()-1 && mNextStationIndex - 1 >=0){
+                    mTwoStationsRouts.clear();
+                    BusStationBean stationNext = mStations.get(mNextStationIndex);
+                    BusStationBean stationCur = mStations.get(mNextStationIndex - 1);
+                    //当前站在轨迹中对应的点
+                    int currentRouteIndex = CoordinateCalculateRouteUtil.getArrivedPointIndexNew(0
+                            ,mRoutePoints
+                            ,stationCur.getGcjLon(),stationCur.getGcjLat());
+                    //要前往的站在轨迹中对应的点
+                    int nextRouteIndex = CoordinateCalculateRouteUtil.getArrivedPointIndexNew(currentRouteIndex
+                            ,mRoutePoints
+                            ,stationNext.getGcjLon(),stationNext.getGcjLat());
+                    CallerLogger.d(M_BUS_P + TAG, "轨迹排查==currentRouteIndex = " + currentRouteIndex
+                            + "， nextRouteIndex = " + nextRouteIndex);
+                    if (currentRouteIndex < nextRouteIndex){ //如果找到的next在起点的轨迹前面，直接舍弃这个轨迹，不显示
+                        mTwoStationsRouts.addAll(mRoutePoints.subList(currentRouteIndex,nextRouteIndex + 1));
+                    }
+                }
+            }
+//            else { //只有两个站点的时候整个路线就是两个站点之间的轨迹
+//                mTwoStationsRouts.clear();
+//                mTwoStationsRouts.addAll(mRoutePoints);
+//            }
+            if (mTwoStationsRouts.size() > 0){
+                float sumLength = CoordinateCalculateRouteUtil.calculateRouteSumLength(mTwoStationsRouts);
+                SharedPrefsMgr.getInstance(mContext).putInt(BusPassengerConst.BUS_SP_KEY_ORDER_SUM_DIS,(int) sumLength);
+                if (mAutopilotPlanningCallback != null){
+                    mAutopilotPlanningCallback.updateTotalDistance();
+                }
+            }
+        }
+    }
+
+    public int getAverageSpeed(){
+            return BusPassengerConst.SHUTTLE_AVERAGE_SPEED;
+    }
+
+    public void loopRouteAndWipe() {
+
+    }
+
+    private void startOrStopOrderLoop(boolean start) {
+        CallerLogger.d(M_BUS_P + TAG, "startOrStopOrderLoop() " + start);
+        if (start) {
+            BusPassengerModelLoopManager.getInstance().startQueryDriverLineLoop();
+        } else {
+            BusPassengerModelLoopManager.getInstance().stopQueryDriverLineLoop();
+        }
+    }
+
+    private void setTrajectoryStation(
+            BusStationBean startStationInfo ,
+            BusStationBean endStationInfo,
+            int lineId
+    ) {
+        MogoLocation startStation = new MogoLocation();
+        startStation.setLongitude(startStationInfo.getGcjLon());
+        startStation.setLatitude(startStationInfo.getGcjLat());
+        MogoLocation endStation = new MogoLocation();
+        endStation.setLongitude(endStationInfo.getGcjLon());
+        endStation.setLatitude(endStationInfo.getGcjLat());
+        TrajectoryAndDistanceManager.INSTANCE.setStationPoint(startStation, endStation, (long)lineId);
+    }
+
+    private void cleanStation(String type) {
+        CallerLogger.d(M_BUS_P + TAG, "清理站点:"+type);
+        TrajectoryAndDistanceManager.INSTANCE.setStationPoint(null, null, -1L);
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/network/BusPassengerModelLoopManager.java

@@ -0,0 +1,60 @@
+package com.mogo.och.shuttle.passenger.network;
+
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
+import com.mogo.och.shuttle.passenger.model.BusPassengerModel;
+
+import java.util.concurrent.TimeUnit;
+
+import io.reactivex.Observable;
+import io.reactivex.android.schedulers.AndroidSchedulers;
+import io.reactivex.disposables.CompositeDisposable;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.schedulers.Schedulers;
+
+import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_BUS_P;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.LOOP_DELAY;
+import static com.mogo.och.shuttle.passenger.constant.BusPassengerConst.LOOP_LINE_2S;
+
+/**
+ * Created on 2021/11/22
+ *
+ * 管理轮询逻辑（订单轮询、新单轮询、新单抢单结果轮询等等）
+ */
+public class BusPassengerModelLoopManager {
+
+    private static final String TAG = BusPassengerModelLoopManager.class.getSimpleName();
+
+    private static final class SingletonHolder {
+        private static final BusPassengerModelLoopManager INSTANCE = new BusPassengerModelLoopManager();
+    }
+
+    public static BusPassengerModelLoopManager getInstance() {
+        return SingletonHolder.INSTANCE;
+    }
+
+    private Disposable mQueryLineDisposable; //心跳轮询
+    private CompositeDisposable mRouteWipeDisposable;
+    private CompositeDisposable mCalculateRouteDisposable; //每隔2s计算一次剩余里程和时间
+
+    public void startQueryDriverLineLoop() {
+        if (mQueryLineDisposable != null && !mQueryLineDisposable.isDisposed()) {
+            return;
+        }
+        CallerLogger.i(M_BUS_P + TAG, "startQueryDriverLineLoop()");
+        mQueryLineDisposable = Observable.interval(LOOP_DELAY,
+                LOOP_LINE_2S, TimeUnit.MILLISECONDS)
+                .map((aLong -> aLong + 1))
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribe(aLong -> BusPassengerModel.getInstance().queryDriverSiteByCoordinate());
+    }
+
+    public void stopQueryDriverLineLoop() {
+        if (mQueryLineDisposable != null) {
+            CallerLogger.i(M_BUS_P + TAG, "stopQueryDriverLineLoop()");
+            mQueryLineDisposable.dispose();
+            mQueryLineDisposable = null;
+        }
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/network/BusPassengerServiceManager.kt

@@ -0,0 +1,77 @@
+package com.mogo.och.shuttle.passenger.network
+
+import android.content.Context
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicManager.getServerToken
+import com.mogo.och.shuttle.passenger.bean.BusPassengerRoutesResponse
+import com.mogo.cloud.passport.MoGoAiCloudClientConfig
+import com.mogo.och.shuttle.passenger.bean.BusPassengerQueryLineRequest
+import com.mogo.och.shuttle.passenger.bean.BusPassengerOperationStatusResponse
+import com.mogo.eagle.core.network.MoGoRetrofitFactory
+import com.mogo.och.common.module.biz.constant.OchCommonConst
+import com.mogo.och.common.module.biz.network.OchCommonServiceCallback
+import com.mogo.och.common.module.biz.network.OchCommonSubscribeImpl
+import com.mogo.och.common.module.biz.network.interceptor.transformTry
+
+/**
+ * Created on 2022/3/31
+ */
+object BusPassengerServiceManager {
+
+    private var driverSnCache = ""
+
+    private var mShuttleBusPassengerServiceApi =
+        MoGoRetrofitFactory.getInstance(OchCommonConst.getShuttleUrl()).create(
+            ShettlePassengerServiceApi::class.java)
+
+    /**
+     * 获取Bus司机端的sn
+     * @return
+     */
+    val driverAppSn: String
+        get() {
+            val serverToken = getServerToken()
+            if (serverToken != driverSnCache && serverToken.isNotEmpty()) {
+                driverSnCache = serverToken
+            }
+            return driverSnCache
+        }
+
+    /**
+     * 查询绑定行驶的小巴车路线
+     * @param context
+     * @param callback
+     */
+    @JvmStatic
+    fun queryDriverSiteByCoordinate(
+        context: Context, callback: OchCommonServiceCallback<BusPassengerRoutesResponse>?
+    ) {
+        mShuttleBusPassengerServiceApi.queryDriverSiteByCoordinate(
+            MoGoAiCloudClientConfig.getInstance().serviceAppId,
+            MoGoAiCloudClientConfig.getInstance().token,
+            BusPassengerQueryLineRequest(
+                driverAppSn
+            )
+        ).transformTry()
+            .subscribe(OchCommonSubscribeImpl(context, callback, "queryDriverSiteByCoordinate"))
+    }
+
+    /**
+     * 查询司机端出车收车状态，以及车牌号
+     * @param context
+     * @param callback
+     */
+    @JvmStatic
+    fun queryDriverOperationStatus(
+        context: Context,
+        callback: OchCommonServiceCallback<BusPassengerOperationStatusResponse>?
+    ) {
+        mShuttleBusPassengerServiceApi.queryDriverOperationStatus(
+            MoGoAiCloudClientConfig.getInstance().serviceAppId,
+            MoGoAiCloudClientConfig.getInstance().token,
+            driverAppSn
+        )
+            .transformTry()
+            .subscribe(OchCommonSubscribeImpl(context, callback, "queryDriverOperationStatus"))
+
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/network/ShettlePassengerServiceApi.java

@@ -0,0 +1,40 @@
+package com.mogo.och.shuttle.passenger.network;
+
+import com.mogo.och.shuttle.passenger.bean.BusPassengerOperationStatusResponse;
+import com.mogo.och.shuttle.passenger.bean.BusPassengerQueryLineRequest;
+import com.mogo.och.shuttle.passenger.bean.BusPassengerRoutesResponse;
+
+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 on 2022/3/31
+ *
+ * Bus乘客端接口定义
+ */
+interface ShettlePassengerServiceApi {
+    /**
+     * 查询bus司机端绑定路线
+     * @return 接口返回数据
+     */
+    @Headers( {"Content-Type:application/json;charset=UTF-8"} )
+    @POST( "/och-shuttle-cabin/api/business/v1/passenger/lineDataWithDriver/query" )
+    Observable<BusPassengerRoutesResponse> queryDriverSiteByCoordinate(@Header("appId") String appId, @Header("ticket") String ticket, @Body BusPassengerQueryLineRequest request);
+
+    /**
+     * 查询司机端的登陆状态
+     * @param sn
+     * @return
+     */
+    @Headers({"Content-type:application/json;charset=UTF-8"})
+//    @GET("/autopilot-car-hailing/car/v2/driver/bus/passenger/takeOrderStatus/query")
+    @GET("/och-shuttle-cabin/api/business/v1/passenger/loginStatus")
+    Observable<BusPassengerOperationStatusResponse> queryDriverOperationStatus(@Header ("appId") String appId, @Header("ticket") String ticket, @Query("sn") String sn);
+
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/presenter/BaseBusPassengerPresenter.java

@@ -0,0 +1,156 @@
+package com.mogo.och.shuttle.passenger.presenter;
+
+import static com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.M_BUS_P;
+
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+
+import com.mogo.commons.AbsMogoApplication;
+import com.mogo.commons.mvp.Presenter;
+import com.mogo.eagle.core.data.map.MogoLocation;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler;
+import com.mogo.och.shuttle.passenger.callback.IBusPassegerDriverStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerADASStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerAutopilotPlanningCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerControllerStatusCallback;
+import com.mogo.och.shuttle.passenger.callback.IBusPassengerRouteLineInfoCallback;
+import com.mogo.och.shuttle.passenger.model.BusPassengerModel;
+import com.mogo.och.shuttle.passenger.ui.BusPassengerRouteFragment;
+import com.mogo.och.data.bean.BusStationBean;
+
+import java.util.List;
+
+/**
+ * Created on 2022/3/31
+ */
+public class BaseBusPassengerPresenter extends Presenter<BusPassengerRouteFragment> implements
+        IBusPassengerADASStatusCallback, IBusPassengerControllerStatusCallback, IBusPassegerDriverStatusCallback, IBusPassengerRouteLineInfoCallback, IBusPassengerAutopilotPlanningCallback {
+    private static final String TAG = BaseBusPassengerPresenter.class.getSimpleName();
+
+    public BaseBusPassengerPresenter(BusPassengerRouteFragment view) {
+        super(view);
+        BusPassengerModel.getInstance().init(AbsMogoApplication.getApp());
+        initListeners();
+    }
+
+    @Override
+    public void onCreate( @NonNull LifecycleOwner owner ) {
+        super.onCreate( owner );
+        CallerLogger.d( M_BUS_P + TAG, "Bus乘客端Presenter onCreate()" );
+    }
+
+    @Override
+    public void onDestroy( @NonNull LifecycleOwner owner ) {
+        super.onDestroy( owner );
+
+        releaseListeners();
+        BusPassengerModel.getInstance().release();
+    }
+
+    private void initListeners() {
+        BusPassengerModel.getInstance().setADASStatusCallback(this);
+        BusPassengerModel.getInstance().setControllerStatusCallback(TAG, this);
+        BusPassengerModel.getInstance().setDriverStatusCallback(this);
+        BusPassengerModel.getInstance().setRouteLineInfoCallback(this);
+        BusPassengerModel.getInstance().setMoGoAutopilotPlanningListener(this);
+    }
+
+    private void releaseListeners() {
+        BusPassengerModel.getInstance().setADASStatusCallback(null);
+        BusPassengerModel.getInstance().setControllerStatusCallback(TAG, null);
+        BusPassengerModel.getInstance().setDriverStatusCallback(null);
+        BusPassengerModel.getInstance().setRouteLineInfoCallback(null);
+        BusPassengerModel.getInstance().setMoGoAutopilotPlanningListener(null);
+    }
+
+    private void runOnUIThread( Runnable executor ) {
+        if ( executor == null ) {
+            return;
+        }
+        if ( Looper.myLooper() != Looper.getMainLooper() ) {
+            UiThreadHandler.post( executor );
+        } else {
+            executor.run();
+        }
+    }
+
+
+    @Override
+    public void onAutopilotArriveEnd() {
+//        mView.showOverviewFragment();
+    }
+
+    @Override
+    public void onAutopilotEnable() {
+        runOnUIThread(() -> mView.onAutopilotStatusChanged(
+                IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_ENABLE));
+    }
+
+    @Override
+    public void onAutopilotDisable() {
+        runOnUIThread(() -> mView.onAutopilotStatusChanged(
+                IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE));
+    }
+
+    @Override
+    public void onAutopilotRunning() {
+        runOnUIThread(() -> mView.onAutopilotStatusChanged(
+                IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING));
+    }
+
+    @Override
+    public void onVRModeChanged(boolean isVRMode) {
+
+    }
+
+    @Override
+    public void onCarLocationChanged(MogoLocation location) {
+        if (location != null){
+            runOnUIThread(() -> mView.onCarLocationChanged(location));
+        }
+    }
+
+    @Override
+    public void changeOperationStatus(boolean changeStatus) {
+        runOnUIThread(() -> mView.changeOperationStatus(changeStatus));
+    }
+
+    @Override
+    public void updatePlateNumber(String plateNumber) {
+//        runOnUIThread(() -> mView.updatePlateNum(plateNumber));
+    }
+
+    @Override
+    public void updateLineInfo(String lineName) {
+        runOnUIThread(() -> mView.updateLineInfo(lineName));
+    }
+
+    @Override
+    public void updateStationsInfo(List<BusStationBean> stations, int currentStationIndex, boolean isArrived) {
+        runOnUIThread(() -> mView.updateStationsInfo(stations,currentStationIndex, isArrived));
+    }
+
+    @Override
+    public void showNoTaskView() {
+        runOnUIThread(() -> mView.showNoTaskView());
+    }
+
+    @Override
+    public void hideNoTaskView() {
+        runOnUIThread(() -> mView.hideNoTaskView());
+    }
+
+    @Override
+    public void routePlanningToNextStationChanged(long meters, long timeInSecond) {
+        runOnUIThread(() -> mView.updateRoutePlanningToNextStation(meters, timeInSecond));
+    }
+
+    @Override
+    public void updateTotalDistance() {
+//        runOnUIThread(() -> mView.setProgressBarMax());
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/provider/B1StatusViewManager.java

@@ -0,0 +1,33 @@
+package com.mogo.och.shuttle.passenger.provider;
+
+import android.content.Context;
+import android.view.View;
+
+import com.mogo.och.shuttle.passenger.ui.BusPStatusBarView;
+import androidx.annotation.NonNull;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.mogo.eagle.core.data.constants.MogoServicePaths;
+import com.mogo.eagle.core.function.api.hmi.view.IStatusViewLayout;
+
+/**
+ * @author congtaowang
+ * @since 2020-01-06
+ * <p>
+ * 根据优先级控制显示 window view.
+ */
+@Route( path = MogoServicePaths.PATH_STATUS_VIEW_MANAGER )
+public class B1StatusViewManager implements IStatusViewLayout {
+
+
+    @NonNull
+    @Override
+    public View getStatusView(Context context) {
+        return new BusPStatusBarView(context);
+    }
+
+    @Override
+    public void init(Context context) {
+
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/BusPBlueToothView.kt

@@ -0,0 +1,36 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import com.mogo.eagle.core.function.api.devatools.IMoGoDevaToolsListener
+import com.mogo.eagle.core.function.hmi.ui.widget.BlueToothView
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.android.synthetic.main.shuttle_p_jl_view_blue_tooth.view.blueView
+
+/**
+ * 魔戒蓝牙控件
+ * 放置于StatusBar右侧位置
+ */
+class BusPBlueToothView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : BlueToothView(context, attrs, defStyleAttr),IMoGoDevaToolsListener {
+
+    init {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_jl_view_blue_tooth, this, true)
+    }
+
+    override fun mofangStatus(status: Boolean) {
+        ThreadUtils.runOnUiThread {
+            if (status) {
+                blueView.setImageResource(R.drawable.shuttle_p_jl_blue_tooth_close)
+            } else {
+                blueView.setImageResource(R.drawable.shuttle_p_jl_blue_tooth_open)
+            }
+        }
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/BusPStatusBarView.kt

@@ -0,0 +1,66 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import android.annotation.*
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.constraintlayout.widget.ConstraintLayout
+import com.mogo.eagle.core.function.api.hmi.view.IViewControlListener
+import com.mogo.eagle.core.function.api.setting.IMoGoSkinModeChangeListener
+import com.mogo.eagle.core.function.call.devatools.CallerDevaToolsManager
+import com.mogo.eagle.core.function.call.hmi.CallerHmiViewControlListenerManager
+import com.mogo.eagle.core.function.call.setting.CallerSkinModeListenerManager
+import com.mogo.eagle.core.utilcode.kotlin.*
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.coroutines.*
+import me.jessyan.autosize.utils.AutoSizeUtils
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/14
+ */
+class BusPStatusBarView @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : ConstraintLayout(context, attrs), IViewControlListener, IMoGoSkinModeChangeListener{
+
+    companion object {
+        const val TAG = "BusPStatusBarView"
+    }
+
+    init {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_jl_view_status_bar, this, true)
+        setBackgroundResource(R.drawable.shuttle_p_jl_bg_status_bar)
+        isClickable = true
+        isFocusable = true
+    }
+
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        post {
+            val params: ViewGroup.LayoutParams = getLayoutParams()
+            params.height = AutoSizeUtils.dp2px(context,40f)
+            layoutParams = params
+        }
+        //添加view控制
+        CallerHmiViewControlListenerManager.addListener(TAG,this)
+        // 添加换肤监听
+        CallerSkinModeListenerManager.addListener(TAG, this)
+    }
+
+    override fun onSkinModeChange(skinMode: Int) {
+        when (skinMode) {
+            0 -> setStatusBarDarkOrLight(false)
+            1 -> setStatusBarDarkOrLight(true)
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerHmiViewControlListenerManager.removeListener(TAG)
+        CallerSkinModeListenerManager.removeListener(TAG)
+        CallerDevaToolsManager.hideStatusBar()
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/BusPassengerBaseFragment.java

@@ -0,0 +1,104 @@
+package com.mogo.och.shuttle.passenger.ui;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.widget.FrameLayout;
+
+import androidx.annotation.NonNull;
+
+import com.mogo.commons.mvp.IView;
+import com.mogo.commons.mvp.MvpFragment;
+
+import com.mogo.commons.mvp.Presenter;
+import com.mogo.eagle.core.function.hmi.ui.widget.RomaPassengerView;
+import com.mogo.eagle.core.function.view.MapBizView;
+import com.mogo.och.shuttle.passenger.R;
+
+/**
+ * Created on 2022/3/31
+ * <p>
+ * Bus乘客端基础Fragment
+ */
+public abstract class BusPassengerBaseFragment<V extends IView, P extends Presenter<V>> extends MvpFragment<V, P> {
+    private static final String TAG = BusPassengerBaseFragment.class.getSimpleName();
+
+    private MapBizView mapBizView;
+    private FrameLayout flContainer;
+    private RomaPassengerView romaPView;
+
+    @Override
+    protected int getLayoutId() {
+        return R.layout.shuttle_p_jl_base_fragment;
+    }
+
+    @Override
+    public String getTagName() {
+        return TAG;
+    }
+
+    @Override
+    protected void initViews() {
+        mapBizView = findViewById(R.id.mapBizView);
+
+        showRouteFragment();
+
+//        mCurrentArriveStation.setOnLongClickListener(new View.OnLongClickListener() {
+//            @Override
+//            public boolean onLongClick(View v) {
+//                showOverviewFragment();
+//                return false;
+//            }
+//        });
+    }
+
+    @Override
+    protected void initViews(Bundle savedInstanceState) {
+        super.initViews(savedInstanceState);
+        mapBizView.onCreate(savedInstanceState);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mapBizView.onResume();
+    }
+
+    @Override
+    public void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mapBizView.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public void onLowMemory() {
+        super.onLowMemory();
+        mapBizView.onLowMemory();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        mapBizView.onPause();
+    }
+
+    @Override
+    public void onDestroyView() {
+        mapBizView.onDestroy();
+        super.onDestroyView();
+    }
+
+    /**
+     * 获取站点面板view，在{@link #initViews()}时候添加到container中
+     *
+     * @return 站点面板view
+     */
+    public abstract int getStationPanelViewId();
+
+    /**
+     * 显示线路信息
+     */
+    public void showRouteFragment() {
+        flContainer = findViewById(R.id.bus_p_route_panel);
+        LayoutInflater.from(getContext()).inflate(getStationPanelViewId(), flContainer);
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/BusPassengerRouteFragment.java

@@ -0,0 +1,359 @@
+package com.mogo.och.shuttle.passenger.ui;
+
+import android.graphics.drawable.AnimationDrawable;
+import android.os.Bundle;
+import android.text.Html;
+import android.view.View;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.widget.AppCompatImageView;
+import androidx.appcompat.widget.AppCompatTextView;
+import androidx.constraintlayout.widget.ConstraintLayout;
+import androidx.constraintlayout.widget.Group;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.amap.api.maps.model.LatLng;
+import com.elegant.utils.UiThreadHandler;
+import com.mogo.eagle.core.data.map.MogoLocation;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener;
+import com.mogo.eagle.core.utilcode.mogo.storage.SharedPrefsMgr;
+import com.mogo.och.shuttle.passenger.R;
+import com.mogo.och.shuttle.passenger.adapter.BusPassengerLineStationsAdapter;
+import com.mogo.och.shuttle.passenger.constant.BusPassengerConst;
+import com.mogo.och.shuttle.passenger.presenter.BaseBusPassengerPresenter;
+import com.mogo.och.shuttle.passenger.ui.layoutmanager.CenterLayoutManager;
+import com.mogo.och.shuttle.passenger.ui.mapdirectionview.BusPassengerMapDirectionView;
+import com.mogo.och.common.module.utils.NumberFormatUtil;
+import com.mogo.och.common.module.wigets.MarqueeTextView;
+import com.mogo.och.common.module.wigets.OCHGradientTextView;
+import com.mogo.och.data.bean.BusStationBean;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/12
+ */
+public class BusPassengerRouteFragment extends
+        BusPassengerBaseFragment<BusPassengerRouteFragment, BaseBusPassengerPresenter> {
+
+    public static final String TAG = "BusPassengerRouteFragment";
+
+    private final List<BusStationBean> mStationsList = new ArrayList<>();
+
+    private OCHGradientTextView mSpeedTv;
+    private ConstraintLayout mNoLineInfoView;
+    private MarqueeTextView mLineName;
+    private Group mRouteInfoView;
+    private RecyclerView mStationsListRv;
+    private BusPassengerMapDirectionView mMapDirectionView;
+    private BusPassengerLineStationsAdapter mAdapter;
+    private TextView emptyTv;
+    private AppCompatImageView mAutopilotIv;
+    private AppCompatTextView mCurrentArriveStation;
+    private AppCompatTextView mCurrentArriveStationTitle;
+    private AppCompatTextView mCurrentArriveTip;
+    private AppCompatImageView mSpeakArrivedIv;
+
+    /**
+     * 改变自动驾驶状态
+     *
+     * @param status 2 - running  1 - enable  2 - disable
+     */
+    private int mPrevAPStatus = -1;
+
+    @Override
+    public int getStationPanelViewId() {
+        return R.layout.shuttle_p_jl_route_fragment;
+    }
+
+    @NonNull
+    @Override
+    protected BaseBusPassengerPresenter createPresenter() {
+        return new BaseBusPassengerPresenter(this);
+    }
+
+    @Override
+    protected void initViews() {
+        super.initViews();
+
+        mSpeedTv = findViewById(R.id.bus_p_speed_tv);
+        mSpeedTv.setVertrial(true);
+        mSpeedTv.setmColorList(new int[]{getResources().getColor(R.color.shuttle_p_jl_speed_color_start),
+                getResources().getColor(R.color.shuttle_p_jl_speed_color_end)});
+
+        mNoLineInfoView =findViewById(R.id.bus_p_no_order_data_view);
+        emptyTv = findViewById(R.id.no_order_data_tv);
+
+//        mCarPlateNum = findViewById(R.id.bus_p_driver_num_plate_tv);
+        mLineName = findViewById(R.id.bus_p_line_name_tv);
+        mAutopilotIv = findViewById(R.id.auto_status_iv);
+        mCurrentArriveStation = findViewById(R.id.bus_p_cur_station_name);
+        mCurrentArriveStationTitle = findViewById(R.id.bus_p_cur_station_title);
+        mCurrentArriveTip = findViewById(R.id.bus_p_cur_station_tip);
+        mSpeakArrivedIv = findViewById(R.id.speak_arrived_iv);
+
+//        mOperationTime = findViewById(R.id.line_operation_time_tv);
+
+        mRouteInfoView = findViewById(R.id.bus_p_line_cl);
+        mStationsListRv = findViewById(R.id.bus_p_line_stations_rl);
+
+        CenterLayoutManager manager = new CenterLayoutManager(getContext());
+        mStationsListRv.setLayoutManager(manager);
+        mAdapter = new BusPassengerLineStationsAdapter(getContext(), mStationsList);
+        mStationsListRv.setAdapter(mAdapter);
+
+//        mMapArrowIcon = findViewById(R.id.bus_p_arrow_nor);
+    }
+
+    @Override
+    protected void initViews(Bundle savedInstanceState) {
+        super.initViews(savedInstanceState);
+        mMapDirectionView = findViewById(R.id.bus_p_line_map_view);
+        mMapDirectionView.onCreateView(savedInstanceState);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (mMapDirectionView != null) {
+            mMapDirectionView.onResume();
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        if (mMapDirectionView != null) {
+            mMapDirectionView.onPause();
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (mMapDirectionView != null) {
+            mMapDirectionView.onDestroy();
+        }
+    }
+
+    public void clearMapView() {
+        if (mMapDirectionView != null) {
+            UiThreadHandler.post(new Runnable() {
+                @Override
+                public void run() {
+//                    mMapDirectionView.clearPolyline();
+//                    mMapDirectionView.clearCoordinatesLatLng();
+                }
+            });
+        }
+    }
+
+    public void clearMapMarkers() {
+        if (mMapDirectionView != null) {
+            UiThreadHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    mMapDirectionView.clearLineMarkers();
+
+                }
+            });
+        }
+    }
+
+    public void changeOperationStatus(boolean status) {
+        if (!status) {
+            emptyTv.setText(getString(R.string.shuttle_p_jl_no_out));
+            mNoLineInfoView.setVisibility(View.VISIBLE);
+            mRouteInfoView.setVisibility(View.GONE);
+            mLineName.setText(getContext().getString(R.string.shuttle_p_jl_no_line));
+            updateArrivedStation(null,0,true);
+            clearMapView();
+            clearMapMarkers();
+        }
+    }
+
+    public void showNoTaskView(){
+         if (mNoLineInfoView.getVisibility() == View.GONE){
+             mNoLineInfoView.setVisibility(View.VISIBLE);
+             mRouteInfoView.setVisibility(View.GONE);
+             mLineName.setText(getContext().getString(R.string.shuttle_p_jl_no_line));
+             updateArrivedStation(null,0,true);
+             clearMapView();
+             clearMapMarkers();
+         }
+        emptyTv.setText(getString(R.string.shuttle_p_jl_no_task));
+    }
+
+    public void hideNoTaskView(){
+        if (mNoLineInfoView.getVisibility() == View.VISIBLE){
+            mNoLineInfoView.setVisibility(View.GONE);
+            mRouteInfoView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void updateLineInfo(String lineName) {
+        mLineName.setText(lineName);
+    }
+
+    /**
+     *
+     * @param stations
+     * @param currentStationIndex
+     * @param isArrived 是否到站并离开，true 到达当前站 currentStationIndex 未离开， false 正在前往此站 currentStationIndex
+     */
+    public void updateStationsInfo(List<BusStationBean> stations, int currentStationIndex, boolean isArrived) {
+        updateArrivedStation(stations.get(currentStationIndex).getName(),currentStationIndex,isArrived);
+        mStationsList.clear();
+        mStationsList.addAll(stations);
+        mAdapter.notifyDataSetChanged();
+
+        if (currentStationIndex > -1){
+            updateCurrentStation(currentStationIndex);
+        }
+
+        if (currentStationIndex == 0 && isArrived){ //到达始发站且并未出发， 恢复站点marker 清楚路径 清空路径点
+            SharedPrefsMgr.getInstance(getContext())
+                    .remove(BusPassengerConst.BUS_SP_KEY_ORDER_SUM_DIS);
+            clearMapView();
+        }
+
+        if (stations.size() > 0){
+            updateWayPointList(stations,currentStationIndex);
+        }
+    }
+
+    private void updateWayPointList(List<BusStationBean> stations,int currentStationIndex) {
+        List<LatLng> mLineStationsList = new ArrayList<>();
+        for (int i = 0; i< stations.size(); i++) {//站点集合
+            LatLng latLng = new LatLng(stations.get(i).getGcjLat(),stations.get(i).getGcjLon());// lat,lon
+            mLineStationsList.add(latLng);
+        }
+
+        if (mMapDirectionView != null) {
+            UiThreadHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    mMapDirectionView.setLinePointMarkerAndDraw(mLineStationsList,currentStationIndex);
+                }
+            });
+        }
+    }
+
+//    @Override
+//    public void onCameraChange(float bearing) {
+////        startIvCompass(bearing);
+//    }
+
+//    /**
+//     * 设置指南针旋转
+//     *
+//     * @param bearing
+//     */
+//    private void startIvCompass(float bearing) {
+//        bearing = 360 - bearing;
+//        CallerLogger.d(M_BUS_P + TAG, "startIvCompass: " + bearing);
+//        rotateAnimation = new RotateAnimation(lastBearing, bearing, Animation.RELATIVE_TO_SELF
+//                , 0.5f, Animation.RELATIVE_TO_SELF, 0.5f);
+//        rotateAnimation.setFillAfter(true);
+//
+//        mMapArrowIcon.startAnimation(rotateAnimation);
+//        lastBearing = bearing;
+//    }
+
+    public void onCarLocationChanged(MogoLocation location) {
+        updateSpeedView((float) location.getGnssSpeed());
+    }
+
+    public void updateSpeedView(float speed){
+        int speedKM = (int) (Math.abs(speed) * 3.6F);
+        mSpeedTv.setText(String.valueOf(speedKM));
+    }
+
+    public void updateCurrentStation(int position) {
+        if (mStationsListRv != null){
+            mStationsListRv.smoothScrollToPosition(position);
+        }
+    }
+
+    public void updateArrivedStation(String station,int currentIndex,boolean isArrived){
+        if (null == station){
+            mCurrentArriveStation.setText("----");
+            mCurrentArriveStationTitle.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_title));
+            mCurrentArriveTip.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_arrived_tip));
+            mCurrentArriveTip.setBackgroundResource(R.drawable.shuttle_p_jl_cur_station_arrived_bg);
+            handleArrivingSpeakIconDrawable();
+        }else {
+            mCurrentArriveStation.setText(station);
+            if (currentIndex == 0){
+                mCurrentArriveStationTitle.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_title));
+                mCurrentArriveTip.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_arrived_tip));
+                mCurrentArriveTip.setBackgroundResource(R.drawable.shuttle_p_jl_cur_station_arrived_bg);
+                handleArrivingSpeakIconDrawable();
+                return;
+            }
+            if (isArrived){
+                mCurrentArriveStationTitle.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_title));
+                mCurrentArriveTip.setText(getResources().getString(R.string.shuttle_p_jl_cur_station_arrived_tip));
+                mCurrentArriveTip.setBackgroundResource(R.drawable.shuttle_p_jl_cur_station_arrived_bg);
+                handleArrivedSpeakIconDrawable();
+            }else {
+                mCurrentArriveStationTitle.setText(getResources().getString(R.string.shuttle_p_jl_cur_next_station_title));
+                mCurrentArriveTip.setBackgroundResource(R.drawable.shuttle_p_jl_cur_station_un_arrived_bg);
+                handleArrivingSpeakIconDrawable();
+            }
+        }
+
+    }
+
+    private void handleArrivedSpeakIconDrawable(){
+        AnimationDrawable animationDrawable = (AnimationDrawable) mSpeakArrivedIv.getDrawable();
+        animationDrawable.start();
+        mSpeakArrivedIv.setVisibility(View.VISIBLE);
+    }
+
+    private void handleArrivingSpeakIconDrawable(){
+        AnimationDrawable animationDrawable = (AnimationDrawable) mSpeakArrivedIv.getDrawable();
+        animationDrawable.stop();
+        mSpeakArrivedIv.setVisibility(View.GONE);
+    }
+
+    public void updateRoutePlanningToNextStation(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);
+            }
+        }
+//        String strHtml2 = "<font color=\"#2D3E5F\">距离 </font>" + "<b><font color=\"#0043FF\">" + dis + "</font></b>" + "<font color=\"#2D3E5F\"> "+disUnit+"</font>"
+//                + "<font color=\"#2D3E5F\"> &nbsp 剩余 </font>" + "<b><font color=\"#0043FF\">" + (int)Math.ceil((double)timeInSecond/ 60f) + "</font></b>" + "<font color=\"#2D3E5F\"> 分钟</font>";
+        String str = dis+disUnit+"  |  "+(int)Math.ceil((double)timeInSecond/ 60f)+"分钟";
+        mCurrentArriveTip.setText(Html.fromHtml(str));
+    }
+
+    public void onAutopilotStatusChanged(int status) {
+        getActivity().runOnUiThread(() -> {
+            // 3. 其他过程直接更新
+            if (mPrevAPStatus != status){
+                AutopilotStatusChanged(status);
+            }
+            mPrevAPStatus = status;
+        });
+    }
+
+    public void AutopilotStatusChanged(int status) {
+        if (IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING == status) {
+            mAutopilotIv.setImageResource(R.drawable.shuttle_p_jl_auto_open);
+        } else {
+            mAutopilotIv.setImageResource(R.drawable.shuttle_p_jl_auto_close);
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/BusPassengerTrafficLightView.kt

@@ -0,0 +1,181 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.widget.LinearLayout
+import com.mogo.eagle.core.data.enums.DataSourceType
+import com.mogo.eagle.core.data.enums.TrafficLightEnum
+import com.mogo.eagle.core.function.api.datacenter.union.IMoGoTrafficLightListener
+import com.mogo.eagle.core.function.call.v2x.CallerTrafficLightListenerManager
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.android.synthetic.main.shuttle_p_jl_traffic_light_view.view.bus_p_traffic_light_bg
+import kotlinx.android.synthetic.main.shuttle_p_jl_traffic_light_view.view.bus_p_traffic_light_iv
+import kotlinx.android.synthetic.main.shuttle_p_jl_traffic_light_view.view.bus_p_traffic_light_time_tv
+
+/**
+ * bus乘客端：红绿灯view
+ *
+ * Created on 2022/3/14
+ */
+class BusPassengerTrafficLightView @JvmOverloads constructor(
+    context: Context?,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : LinearLayout(context, attrs, defStyleAttr), IMoGoTrafficLightListener {
+
+    companion object {
+        private const val TAG = "BusPassengerTrafficLightView"
+    }
+
+    private var mCurrentLightId = TrafficLightEnum.BLACK
+
+    init {
+        init(context)
+    }
+
+    private fun init(context: Context?) {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_jl_traffic_light_view, this, true)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        CallerTrafficLightListenerManager.addListener(TAG, this)
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerTrafficLightListenerManager.removeListener(TAG)
+    }
+
+    /**
+     * 展示红绿灯预警
+     *
+     * @param checkLightId 0-都是默认，1-红，2-黄，3-绿
+     * @param lightSource 1:云端下发；2:自车感知
+     */
+    override fun showTrafficLight(checkLightId: TrafficLightEnum, lightSource: DataSourceType) {
+        super.showTrafficLight(checkLightId, lightSource)
+        mCurrentLightId = checkLightId
+        updateTrafficLightIcon(checkLightId)
+    }
+
+    /**
+     * 关闭红绿灯预警展示，并重制灯态
+     */
+    override fun disableTrafficLight() {
+        super.disableTrafficLight()
+        UiThreadHandler.post {
+            mCurrentLightId = TrafficLightEnum.BLACK
+            this@BusPassengerTrafficLightView.visibility = GONE
+        }
+    }
+
+    /**
+     * @param redNum 红灯倒计时
+     * @param yellowNum 黄灯倒计时
+     * @param greenNum 绿灯倒计时
+     */
+    override fun changeCountdownTrafficLightNum(redNum: Int, yellowNum: Int, greenNum: Int) {
+        super.changeCountdownTrafficLightNum(redNum, yellowNum, greenNum)
+        resetView()
+        when (mCurrentLightId) {
+            TrafficLightEnum.RED -> changeCountdownRed(redNum)
+            TrafficLightEnum.YELLOW -> changeCountdownYellow(yellowNum)
+            TrafficLightEnum.GREEN -> changeCountdownGreen(greenNum)
+            else -> UiThreadHandler.post { bus_p_traffic_light_time_tv.text = "" }
+        }
+    }
+
+    override fun changeCountdownRed(redNum: Int) {
+        super.changeCountdownRed(redNum)
+        UiThreadHandler.post {
+            if (redNum > 0) {
+                resetView()
+                bus_p_traffic_light_time_tv.text = redNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                bus_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    override fun changeCountdownGreen(greenNum: Int) {
+        super.changeCountdownGreen(greenNum)
+        UiThreadHandler.post {
+            if (greenNum > 0) {
+                resetView()
+                bus_p_traffic_light_time_tv.text = greenNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                bus_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    override fun changeCountdownYellow(yellowNum: Int) {
+        super.changeCountdownYellow(yellowNum)
+        UiThreadHandler.post {
+            if (yellowNum > 0) {
+                resetView()
+                bus_p_traffic_light_time_tv.text = yellowNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                bus_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    /**
+     * 更新红绿灯icon
+     *
+     * @param lightId 0-都是默认，1-红，2-黄，3-绿
+     */
+    private fun updateTrafficLightIcon(lightId: TrafficLightEnum) {
+        UiThreadHandler.post {
+            when (lightId) {
+                TrafficLightEnum.RED -> {
+                    bus_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_jl_light_red_nor)
+                    this@BusPassengerTrafficLightView.visibility = VISIBLE
+                }
+                TrafficLightEnum.YELLOW -> {
+                    bus_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_jl_light_yellow_nor)
+                    this@BusPassengerTrafficLightView.visibility = VISIBLE
+                }
+                TrafficLightEnum.GREEN -> {
+                    bus_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_jl_light_green_nor)
+                    this@BusPassengerTrafficLightView.visibility = VISIBLE
+                }
+                else -> this@BusPassengerTrafficLightView.visibility = GONE
+            }
+        }
+    }
+
+    override fun disableTrafficLightCountDown() {
+        super.disableTrafficLightCountDown()
+        UiThreadHandler.post {
+            val layoutParams = layoutParams
+            if (layoutParams is MarginLayoutParams) {
+                val lp = layoutParams
+                lp.width = resources.getDimension(R.dimen.shuttle_p_jl_traffic_light_icon_size).toInt()
+                setLayoutParams(lp)
+                bus_p_traffic_light_time_tv.visibility = GONE
+                bus_p_traffic_light_bg.layoutParams.width =
+                    resources.getDimension(R.dimen.dp_90).toInt()
+            }
+        }
+    }
+
+    private fun resetView() {
+        val layoutParams = layoutParams
+        if (layoutParams is MarginLayoutParams) {
+            val lp = layoutParams
+            lp.width = resources.getDimension(R.dimen.shuttle_p_jl_route_traffic_light_view_width).toInt()
+            setLayoutParams(lp)
+            bus_p_traffic_light_time_tv.visibility = VISIBLE
+            bus_p_traffic_light_bg.layoutParams.width =
+                resources.getDimension(R.dimen.shuttle_p_jl_traffic_light_bg_width).toInt()
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/IBusPassengerMapDirectionView.java

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

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/layoutmanager/CenterLayoutManager.java

@@ -0,0 +1,42 @@
+package com.mogo.och.shuttle.passenger.ui.layoutmanager;
+
+import android.content.Context;
+import android.util.AttributeSet;
+
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.LinearSmoothScroller;
+import androidx.recyclerview.widget.RecyclerView;
+
+public class CenterLayoutManager extends LinearLayoutManager {
+    public CenterLayoutManager(Context context) {
+        super(context);
+    }
+
+    public CenterLayoutManager(Context context, int orientation, boolean reverseLayout) {
+        super(context, orientation, reverseLayout);
+    }
+
+    public CenterLayoutManager(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    @Override
+    public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position) {
+        RecyclerView.SmoothScroller smoothScroller = new CenterSmoothScroller(recyclerView.getContext());
+        smoothScroller.setTargetPosition(position);
+        startSmoothScroll(smoothScroller);
+    }
+
+    private static class CenterSmoothScroller extends LinearSmoothScroller {
+
+        CenterSmoothScroller(Context context) {
+            super(context);
+        }
+
+        @Override
+        public int calculateDtToFit(int viewStart, int viewEnd, int boxStart, int boxEnd, int snapPreference) {
+            return (boxStart + (boxEnd - boxStart) / 2) - (viewStart + (viewEnd - viewStart) / 2);
+        }
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/mapdirectionview/BusPassengerMapDirectionView.kt

@@ -0,0 +1,350 @@
+package com.mogo.och.shuttle.passenger.ui.mapdirectionview
+
+import android.content.Context
+import android.os.Bundle
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.View
+import android.widget.RelativeLayout
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.findViewTreeViewModelStoreOwner
+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.function.call.autopilot.CallerChassisLocationGCJ02ListenerManager
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.ui.IBusPassengerMapDirectionView
+import com.mogo.och.shuttle.passenger.utils.BusPassengerMapAssetStyleUtil
+
+/**
+ * 乘客屏小地图
+ */
+class BusPassengerMapDirectionView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : RelativeLayout(context, attrs, defStyleAttr), IMoGoChassisLocationGCJ02Listener,
+    IBusPassengerMapDirectionView, AMap.OnCameraChangeListener,
+    MapDirectionViewModel.ItineraryViewCallback {
+    companion object {
+        //小地图名称
+        const val TAG = "BusPassengerMapDirectionView"
+    }
+
+    private lateinit var mAMapNaviView: TextureMapView
+    private lateinit var mAMap: AMap
+    private var mPolyline: Polyline? = null
+    private val mLineMarkers: MutableList<Marker> = ArrayList()
+    private lateinit var mCarMarker: Marker
+
+    private val mLineStationLatLng: MutableList<LatLng> = ArrayList() //站点坐标数据
+    var textureList: MutableList<BitmapDescriptor?> = ArrayList()
+    var texIndexList: MutableList<Int> = ArrayList()
+    private var mArrivedRes: BitmapDescriptor? = null
+    private var mUnArrivedRes: BitmapDescriptor? = null
+
+    private val routeArrived: MutableList<LatLng> = ArrayList()
+    private val routeArriving: MutableList<LatLng> = ArrayList()
+    private var location: MogoLocation? = null
+
+    init {
+        try {
+            initView(context)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun initView(context: Context) {
+        d(SceneConstant.M_BUS_P + TAG, "initView")
+        val smpView = LayoutInflater.from(context).inflate(R.layout.shuttle_p_jl_map_view, this)
+        mAMapNaviView = smpView.findViewById<View>(R.id.bus_p_line_amap_view) as TextureMapView
+        initAMapView()
+
+        // 注册定位监听
+        CallerChassisLocationGCJ02ListenerManager.addListener(TAG, 10, this)
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        // 注册定位监听
+        CallerChassisLocationGCJ02ListenerManager.removeListener(TAG)
+    }
+
+    private fun initAMapView() {
+        mAMap = mAMapNaviView.map
+        // 设置导航地图模式，aMap是地图控制器对象。
+        mAMap.mapType = AMap.MAP_TYPE_NIGHT
+
+        // 关闭显示实时路况图层，aMap是地图控制器对象。
+        mAMap.isTrafficEnabled = false
+
+        // 设置 锚点 图标
+        mCarMarker = mAMap.addMarker(
+            MarkerOptions().icon(BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_car))
+                .anchor(0.5f, 0.5f)
+        )
+        mArrivedRes = BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_arrow_arrived)
+        mUnArrivedRes = BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_arrow_un_arrive)
+
+        // 加载自定义样式
+        val customMapStyleOptions = CustomMapStyleOptions()
+            .setEnable(true)
+            .setStyleData(
+                BusPassengerMapAssetStyleUtil.getAssetsStyle(
+                    context, "map_style.data"
+                )
+            )
+            .setStyleExtraData(
+                BusPassengerMapAssetStyleUtil.getAssetsExtraStyle(
+                    context, "map_style_extra.data"
+                )
+            )
+        // 设置自定义样式
+        mAMap.setCustomMapStyle(customMapStyleOptions)
+
+        // 设置地图的样式
+        mAMap.uiSettings.apply {
+            isZoomControlsEnabled = false // 地图缩放级别的交换按钮
+            setAllGesturesEnabled(true) // 所有手势
+            isMyLocationButtonEnabled = false // 显示默认的定位按钮
+            setLogoBottomMargin(-150) //设置Logo下边界距离屏幕底部的边距,设置为负值即可
+        }
+
+        mAMap.setOnMapLoadedListener {
+            d(SceneConstant.M_BUS_P + TAG, "smp---onMapLoaded")
+            // 加载自定义样式
+            val options = CustomMapStyleOptions()
+                .setEnable(true)
+                .setStyleData(
+                    BusPassengerMapAssetStyleUtil.getAssetsStyle(
+                        context, "map_style.data"
+                    )
+                )
+                .setStyleExtraData(
+                    BusPassengerMapAssetStyleUtil.getAssetsExtraStyle(
+                        context, "map_style_extra.data"
+                    )
+                )
+            // 设置自定义样式
+            mAMap.setCustomMapStyle(options)
+            mAMapNaviView.map.setPointToCenter(
+                mAMapNaviView.width / 2,
+                mAMapNaviView.height / 2
+            )
+        }
+
+        //设置地图状态的监听接口
+        mAMap.setOnCameraChangeListener(this)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        val viewModel = findViewTreeViewModelStoreOwner()?.let {
+            ViewModelProvider(it).get(MapDirectionViewModel::class.java)
+        }
+        viewModel?.setDistanceCallback(this)
+    }
+
+    fun clearMapView() {
+        UiThreadHandler.post( {
+            clearPolyline()
+            clearCoordinatesLatLng()
+        }, UiThreadHandler.MODE.QUEUE)
+    }
+
+    override fun onChassisLocationGCJ02(mogoLocation: MogoLocation?) {
+        if (mogoLocation == null) {
+            return
+        }
+        val currentLatLng = LatLng(mogoLocation.latitude, mogoLocation.longitude)
+
+        //更新车辆位置
+        mCarMarker.rotateAngle = (360 - mogoLocation.heading).toFloat()
+        mCarMarker.position = currentLatLng
+        mCarMarker.setToTop()
+        try {
+            //圈定地图显示范围
+            val boundsBuilder = LatLngBounds.Builder()
+            routeArrived.forEach {
+                boundsBuilder.include(it)
+            }
+            routeArriving.forEach {
+                boundsBuilder.include(it)
+            }
+            mLineStationLatLng.forEach {
+                boundsBuilder.include(it)
+            }
+            boundsBuilder.include(currentLatLng)
+            mAMap.moveCamera(
+                CameraUpdateFactory.newLatLngBoundsRect(
+                    boundsBuilder.build(),
+                    100,
+                    100,
+                    100,
+                    100
+                )
+            )
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    override fun drawablePolyline() {
+        if (routeArrived.isEmpty() && routeArriving.isEmpty()) {
+            d(SceneConstant.M_TAXI + TAG, "没有点")
+            return
+        }
+        texIndexList.clear()
+        val allPoints = ArrayList(routeArrived)
+        for (i in routeArrived.indices) {
+            if (routeArrived.size > 1 && i < routeArrived.size - 1) {
+                texIndexList.add(0)
+            }
+        }
+        texIndexList.add(0)
+        location?.let {
+            allPoints.add(LatLng(it.latitude, it.longitude))
+        }
+        allPoints.addAll(routeArriving)
+        for (ignored in routeArrived) {
+            texIndexList.add(1)
+        }
+        mPolyline?.let {
+            it.points = allPoints
+            it.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() {
+        mPolyline?.remove()
+        mPolyline = null
+    }
+
+    override fun setLineMarker() {}
+
+    fun clearCoordinatesLatLng() {
+        textureList.clear()
+        texIndexList.clear()
+        routeArrived.clear()
+        routeArriving.clear()
+        mLineStationLatLng.clear()
+        d(SceneConstant.M_BUS_P + TAG, " mCoordinatesLatLng.clear ")
+    }
+
+    fun onCreateView(savedInstanceState: Bundle?) {
+        mAMapNaviView.onCreate(savedInstanceState)
+    }
+
+    fun onResume() {
+        mAMapNaviView.onResume()
+    }
+
+    fun onPause() {
+        mAMapNaviView.onPause()
+    }
+
+    fun onDestroy() {
+        mAMapNaviView.onDestroy()
+    }
+
+    override fun setCoordinatesLatLng(
+        routeArrived: List<LatLng>,
+        routeArriving: List<LatLng>,
+        location: MogoLocation?
+    ) {
+        this.routeArrived.clear()
+        this.routeArrived.addAll(routeArrived)
+        this.routeArriving.clear()
+        this.routeArriving.addAll(routeArriving)
+        this.location = location
+        UiThreadHandler.post({
+            drawablePolyline()
+        }, UiThreadHandler.MODE.QUEUE)
+    }
+
+    fun clearLineMarkers() {
+        for (i in mLineMarkers.indices) {
+            mLineMarkers[i].isVisible = false
+            mLineMarkers[i].remove()
+        }
+        mLineMarkers.clear()
+    }
+
+    fun setLinePointMarkerAndDraw(mLineStationsList: List<LatLng>, currentIndex: Int) {
+        clearLineMarkers()
+        mLineStationLatLng.clear()
+        mLineStationLatLng.addAll(mLineStationsList)
+        if (mLineStationsList.isNotEmpty()) {
+            // 起点marker, 终点marker, 过站marker, 未过站marker
+            val size = mLineStationsList.size
+            val mStartMarker = mAMap.addMarker(
+                MarkerOptions()
+                    .icon(BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_start_point))
+            )
+            val mEndMarker = mAMap.addMarker(
+                MarkerOptions()
+                    .icon(BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_end_point))
+            )
+            mStartMarker.position = mLineStationsList[0]
+            mLineMarkers.add(0, mStartMarker)
+            for (i in mLineStationsList.indices) {
+                if (currentIndex <= i && i < size - 1 && i > 0) { //未到达
+                    val unArrivedMarker = mAMap.addMarker(
+                        MarkerOptions()
+                            .icon(BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_unarrived_point))
+                    )
+                    unArrivedMarker.position = mLineStationsList[i]
+                    mLineMarkers.add(i, unArrivedMarker)
+                } else if (i in 1 until currentIndex) {
+                    val arrivedMarker = mAMap.addMarker(
+                        MarkerOptions()
+                            .icon(BitmapDescriptorFactory.fromResource(R.drawable.shuttle_p_jl_map_arrived_point))
+                    )
+                    arrivedMarker.position = mLineStationsList[i]
+                    mLineMarkers.add(i, arrivedMarker)
+                }
+            }
+            mEndMarker.position = mLineStationsList[size - 1]
+            mLineMarkers.add(size - 1, mEndMarker)
+        }
+    }
+
+    override fun onCameraChange(cameraPosition: CameraPosition) {
+    }
+
+    override fun onCameraChangeFinish(cameraPosition: CameraPosition) {}
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/mapdirectionview/MapDirectionViewModel.kt

@@ -0,0 +1,60 @@
+package com.mogo.och.shuttle.passenger.ui.mapdirectionview
+
+import androidx.lifecycle.ViewModel
+import com.amap.api.maps.model.LatLng
+import com.mogo.eagle.core.data.map.MogoLocation
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
+import com.mogo.och.common.module.manager.distancemamager.ITrajectoryListener
+import com.mogo.och.common.module.manager.distancemamager.TrajectoryAndDistanceManager
+
+class MapDirectionViewModel: ViewModel(), ITrajectoryListener {
+
+    private val TAG = MapDirectionViewModel::class.java.simpleName
+
+    private var viewCallback: ItineraryViewCallback?=null
+
+
+    init {
+        TrajectoryAndDistanceManager.addTrajectoryListener(TAG,this)
+    }
+
+    fun setDistanceCallback(viewCallback: ItineraryViewCallback){
+        this.viewCallback = viewCallback
+    }
+
+
+    override fun onCleared() {
+        super.onCleared()
+        this.viewCallback = null
+        TrajectoryAndDistanceManager.removeListener(TAG)
+    }
+
+    interface ItineraryViewCallback{
+        fun setCoordinatesLatLng(routeArrived: List<LatLng>, routeArriving: List<LatLng>, location: MogoLocation?)
+    }
+
+    override fun trajectoryCallback(
+        routeArrivied: MutableList<MogoLocation>,
+        routeArriving: MutableList<MogoLocation>,
+        location: MogoLocation
+    ) {
+        val routeArrivedTemp: MutableList<LatLng> = ArrayList()
+        val routeArrivingTemp: MutableList<LatLng> = ArrayList()
+        var temp: LatLng
+        for (mogoLocation in routeArrivied) {
+            temp = LatLng(mogoLocation.latitude, mogoLocation.longitude)
+            routeArrivedTemp.add(temp)
+        }
+        for (mogoLocation in routeArriving) {
+            temp = LatLng(mogoLocation.latitude, mogoLocation.longitude)
+            routeArrivingTemp.add(temp)
+        }
+        this.viewCallback?.setCoordinatesLatLng(
+            routeArrivedTemp,
+            routeArrivingTemp,
+            location
+        )
+        CallerLogger.d(TAG,"已经走过的点routeArrivied:${routeArrivied.size} 未走过的点：routeArriving：${routeArriving.size}")
+    }
+
+}

OCH/shuttle/passenger/src/main/java/jinlv/com/mogo/och/shuttle/passenger/ui/widget/BusPTurnLightView.kt

@@ -0,0 +1,199 @@
+package com.mogo.och.shuttle.passenger.ui.widget
+
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.View
+import android.view.animation.AlphaAnimation
+import android.view.animation.Animation
+import android.widget.ImageView
+import androidx.constraintlayout.widget.ConstraintLayout
+import com.mogo.eagle.core.function.api.datacenter.union.IMoGoTurnLightListener
+import com.mogo.eagle.core.function.call.autopilot.CallerChassisLamplightListenerManager
+import com.mogo.eagle.core.function.call.v2x.CallerTurnLightListenerManager
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.common.module.manager.lightmanager.TurnLightManager
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.left_nor_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.left_select_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.right_nor_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.right_select_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.turn_light_layout
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/13
+ */
+class BusPTurnLightView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : ConstraintLayout(context, attrs, defStyleAttr),
+    IMoGoTurnLightListener, TurnLightManager.TurnLightListener {
+
+
+    companion object {
+        private const val TAG = "TurnLightViewStatus"
+    }
+
+    private var isLeftLight: Boolean = false
+    private var isRightLight: Boolean = false
+    private var isDisappear: Boolean = false
+
+    init {
+        LayoutInflater.from(context)
+            .inflate(R.layout.shuttle_p_jl_turn_light_status, this, true)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        CallerTurnLightListenerManager.addListener(TAG,this)
+
+        TurnLightManager.addTurnLightStatusChangeListener(TAG,this)
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerChassisLamplightListenerManager.removeListener(TAG)
+        CallerTurnLightListenerManager.removeListener(TAG)
+    }
+
+    override fun hideTurnLightView() {
+        ThreadUtils.runOnUiThread{
+            if (!isDisappear) {
+                isDisappear = true
+                isLeftLight = false
+                isRightLight = false
+                animationDisappear()
+            }
+        }
+    }
+
+    override fun statusChange(newStatus: TurnLightManager.TurnLightStatus) {
+        ThreadUtils.runOnUiThread {
+            setTurnLight(newStatus)
+        }
+    }
+
+    /**
+     * 转向灯动画
+     */
+    private fun setTurnLight(directionLight: TurnLightManager.TurnLightStatus) {
+        if (!isAttachedToWindow) {
+            return
+        }
+        //根据左右进行显示和隐藏，实际要判断每个来的时间和频度
+        when (directionLight) {
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_LEFT -> { //左转向
+                if (!isLeftLight) {
+                    isLeftLight = true
+                    isRightLight = false
+                    isDisappear = false
+                    showNormalAnimation()
+                    left_select_image.visibility = View.VISIBLE
+                    right_select_image.visibility = View.GONE
+                    right_select_image.clearAnimation()
+                    setAnimation(left_select_image)
+                }
+            }
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_RIGHT -> { //右转向
+                if (!isRightLight) {
+                    isRightLight = true
+                    isLeftLight = false
+                    isDisappear = false
+                    showNormalAnimation()
+                    left_select_image.visibility = View.GONE
+                    right_select_image.visibility = View.VISIBLE
+                    left_select_image.clearAnimation()
+                    setAnimation(right_select_image)
+                }
+            }
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_NONE -> { //消失
+                if (!isDisappear) {
+                    isDisappear = true
+                    isLeftLight = false
+                    isRightLight = false
+                    animationDisappear()
+                }
+            }
+        }
+    }
+
+    //显示背景
+    private fun showNormalAnimation() {
+        val appearAnimation = AlphaAnimation(0f, 1.0f)
+        appearAnimation.duration = 300
+        val appearAnimationImage = AlphaAnimation(0f, 1.0f)
+        appearAnimation.duration = 500
+        turn_light_layout.startAnimation(appearAnimation)
+        left_nor_image.startAnimation(appearAnimationImage)
+        right_nor_image.startAnimation(appearAnimationImage)
+
+        turn_light_layout.visibility = View.VISIBLE
+        left_nor_image.visibility = View.VISIBLE
+        right_nor_image.visibility = View.VISIBLE
+    }
+
+    //消失动画，当转向等数据为空时候
+    private fun animationDisappear() {
+        left_select_image.visibility = View.GONE
+        right_select_image.visibility = View.GONE
+        left_select_image.clearAnimation()
+        right_select_image.clearAnimation()
+
+        left_nor_image.clearAnimation()
+        right_nor_image.clearAnimation()
+        turn_light_layout.clearAnimation()
+
+        val disappearAnimationLeft = AlphaAnimation(1.0f, 0f)
+        disappearAnimationLeft.duration = 300
+
+        val disappearAnimationBg = AlphaAnimation(1.0f, 0f)
+        disappearAnimationBg.duration = 500
+
+        left_nor_image.startAnimation(disappearAnimationLeft)
+        right_nor_image.startAnimation(disappearAnimationLeft)
+        turn_light_layout.startAnimation(disappearAnimationBg)
+
+        disappearAnimationLeft.setAnimationListener(object : Animation.AnimationListener {
+            override fun onAnimationRepeat(p0: Animation?) {
+            }
+
+            override fun onAnimationStart(p0: Animation?) {
+            }
+
+            override fun onAnimationEnd(p0: Animation?) {
+                left_nor_image.visibility = View.GONE
+                right_nor_image.visibility = View.GONE
+            }
+        })
+
+        disappearAnimationBg.setAnimationListener(object : Animation.AnimationListener {
+            override fun onAnimationRepeat(p0: Animation?) {
+            }
+
+            override fun onAnimationStart(p0: Animation?) {
+            }
+
+            override fun onAnimationEnd(p0: Animation?) {
+                turn_light_layout.visibility = View.GONE
+            }
+        })
+    }
+
+    //实现图片闪烁效果
+    private fun setAnimation(imageView: ImageView) {
+        val animationSet = AnimatorSet()
+        val valueAnimator = ObjectAnimator.ofFloat(imageView, "alpha", 0f, 1.0f)
+        val valueAnimatorDisappear = ObjectAnimator.ofFloat(imageView, "alpha", 1.0f, 0f)
+        valueAnimator.duration = 1000
+        valueAnimatorDisappear.duration = 800
+        valueAnimator.repeatCount = -1
+        valueAnimatorDisappear.repeatCount = -1
+        animationSet.playTogether(valueAnimatorDisappear, valueAnimator)
+        animationSet.start()
+    }
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/bean/PM2OperationStatusResponse.java

@@ -0,0 +1,21 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import com.mogo.eagle.core.data.BaseData;
+
+/**
+ * @author congtaowang
+ * @since 2021/3/22
+ *
+ * 小巴车运营状态返回参数
+ */
+public class PM2OperationStatusResponse extends BaseData {
+
+    public Result data;
+
+    public static class Result {
+        private String sn; //司机屏sn
+        private String phone; //司机手机号
+        public String plateNumber; //车牌号
+        public int driverStatus;//0:已收车，1:已出车
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/bean/PM2QueryLineRequest.java

@@ -0,0 +1,16 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+public
+/**
+ * @author congtaowang
+ * @since 2021/3/22
+ *
+ * 根据车机行驶线路站点信息
+ */
+class PM2QueryLineRequest {
+
+    private String sn;
+    public PM2QueryLineRequest(String sn) {
+        this.sn = sn;
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/bean/PM2RoutesResponse.java

@@ -0,0 +1,29 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import com.mogo.eagle.core.data.BaseData;
+import com.mogo.och.data.bean.BusRoutesResult;
+
+/**
+ * 网约车小巴路线接口请求响应结果 返回的是对应司机屏的线路信息
+ *
+ * @author tongchenfei
+ */
+public class PM2RoutesResponse extends BaseData {
+    private BusRoutesResult data;
+
+    public BusRoutesResult getResult() {
+        return data;
+    }
+
+    public void setResult(BusRoutesResult data) {
+        this.data = data;
+    }
+
+    @Override
+    public String toString() {
+        return "OchBusRoutesResponse{" +
+                "data=" + data +
+                '}';
+    }
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/bean/PM2RoutesResult.java

@@ -0,0 +1,79 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 网约车小巴路线接口返回接口数据封装
+ *
+ * @author tongchenfei
+ */
+public class PM2RoutesResult {
+    private List<PM2Station> sites;
+    private int lineId;
+    private String name; //线路名称
+    private int lineType;  //线路类型，0:环形
+    private String description;
+    private int status;
+    private String runningDur; //运营时间
+    private long taskTime; //线路时间班次
+
+    public List<PM2Station> getSites() {
+        return sites;
+    }
+
+    public int getLineId() {
+        return lineId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getLineType() {
+        return lineType;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public String getRunningDur() {
+        return runningDur;
+    }
+
+    @Override
+    public String toString() {
+        return "BusPassengerRoutesResult{" +
+                "sites=" + sites +
+                ", lineId=" + lineId +
+                ", name='" + name + '\'' +
+                ", lineType=" + lineType +
+                ", description='" + description + '\'' +
+                ", status=" + status +
+                ", runningDur='" + runningDur + '\'' +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PM2RoutesResult that = (PM2RoutesResult) o;
+        return lineId == that.lineId
+                && lineType == that.lineType
+                && status == that.status
+                && sites.equals(that.sites)
+                && name.equals(that.name)
+                && runningDur.equals(that.runningDur);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sites, lineId, name, lineType, description, status, runningDur);
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/bean/PM2Station.java

@@ -0,0 +1,173 @@
+package com.mogo.och.shuttle.passenger.bean;
+
+import java.util.Objects;
+
+/**
+ * 单个网约车小巴车站信息
+ *
+ * @author wangmingjun
+ */
+public class PM2Station {
+
+    private String name;
+    private String description;
+    private String cityCode;
+    private double lon; //高精坐标
+    private double lat; //高精坐标
+    private double gcjLon; //高德坐标
+    private double gcjLat; //高德坐标
+    private int businessType; //站点类型，9:taxi，10:bus
+    private int status;
+    private int siteId;
+    private int seq;
+    private int drivingStatus;//行驶信息，0初始值；1已经过；2当前站；3未到站
+    private int ifStop = 1; // 是否需要停靠、1需要、0不需要   // TODO: 2021/10/19 原来站点里有设计是否需要停靠字段，现设计暂无，默认都需要停靠
+    private boolean leaving;
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public void setCityCode(String cityCode) {
+        this.cityCode = cityCode;
+    }
+
+    public void setLon(double lon) {
+        this.lon = lon;
+    }
+
+    public void setLat(double lat) {
+        this.lat = lat;
+    }
+
+    public void setBusinessType(int businessType) {
+        this.businessType = businessType;
+    }
+
+    public void setStatus(int status) {
+        this.status = status;
+    }
+
+    public void setSiteId(int siteId) {
+        this.siteId = siteId;
+    }
+
+    public void setSeq(int seq) {
+        this.seq = seq;
+    }
+
+    public void setDrivingStatus(int drivingStatus) {
+        this.drivingStatus = drivingStatus;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public String getCityCode() {
+        return cityCode;
+    }
+
+    public double getGcjLon() {
+        return gcjLon;
+    }
+
+    public double getGcjLat() {
+        return gcjLat;
+    }
+
+    public int getBusinessType() {
+        return businessType;
+    }
+
+    public int getStatus() {
+        return status;
+    }
+
+    public int getSiteId() {
+        return siteId;
+    }
+
+    public int getSeq() {
+        return seq;
+    }
+
+    public int getDrivingStatus() {
+        return drivingStatus;
+    }
+
+    public double getLon() {
+        return lon;
+    }
+
+    public double getLat() {
+        return lat;
+    }
+
+    public void setIfStop(int ifStop) {
+        this.ifStop = ifStop;
+    }
+
+    public int getIfStop() {
+        return ifStop;
+    }
+
+    public void setLeaving(boolean leaving) {
+        this.leaving = leaving;
+    }
+
+    public boolean isLeaving() {
+        return leaving;
+    }
+
+    @Override
+    public String toString() {
+        return "OchBusStation{" +
+                "name='" + name + '\'' +
+                ", description='" + description + '\'' +
+                ", cityCode='" + cityCode + '\'' +
+                ", lon=" + lon +
+                ", lat=" + lat +
+                ", businessType=" + businessType +
+                ", status=" + status +
+                ", siteId=" + siteId +
+                ", seq=" + seq +
+                ", drivingStatus=" + drivingStatus +
+                ", ifStop=" + ifStop +
+                ", leaving=" + leaving +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PM2Station that = (PM2Station) o;
+        return Double.compare(that.lon, lon) == 0
+                && Double.compare(that.lat, lat) == 0
+                && Double.compare(that.gcjLon, gcjLon) == 0
+                && Double.compare(that.gcjLat, gcjLat) == 0
+                && businessType == that.businessType
+                && status == that.status
+                && siteId == that.siteId
+                && seq == that.seq
+                && drivingStatus == that.drivingStatus
+                && ifStop == that.ifStop
+                && leaving == that.leaving
+                && Objects.equals(name, that.name)
+                && Objects.equals(cityCode, that.cityCode);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, description, cityCode, lon, lat, gcjLon, gcjLat, businessType, status, siteId, seq, drivingStatus, ifStop, leaving);
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/callback/ADASCallback.kt

@@ -0,0 +1,10 @@
+package com.mogo.och.shuttle.passenger.callback
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/15
+ */
+interface ADASCallback {
+    fun updateHDMapStations(stations: MutableList<MutableList<Double>>)
+    fun removeHDMapStations()
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/callback/AutoPilotStatusCallback.kt

@@ -0,0 +1,14 @@
+package com.mogo.och.shuttle.passenger.callback
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/13
+ */
+interface AutoPilotStatusCallback {
+    /**
+     * false: 未开启自驾， true ： 开启自驾
+     */
+    fun updateAutoStatus(isOpen: Boolean)
+
+    fun updateAutoStatus(status: Int)
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/callback/DrivingInfoCallback.kt

@@ -0,0 +1,19 @@
+package com.mogo.och.shuttle.passenger.callback
+
+import com.mogo.och.data.bean.BusStationBean
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/2
+ */
+interface DrivingInfoCallback {
+    fun updateSpeed(speed: Int)
+    fun updatePlateNumber(carNum: String)
+    fun updateLine(lineName: String, lineDuring: String)
+    fun updateRemainMT(meters : Long, timeInSecond : Long) // 米，秒
+    fun changeOperationStatus(loginStatus : Boolean)
+    fun showNoTaskView(isTrue : Boolean)
+    fun updateLineStations(stations: MutableList<BusStationBean>)
+    fun updateStationsInfo(stations: MutableList<BusStationBean>, i: Int, isArrived: Boolean)
+    fun clearCustomPolyline()
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/constant/M2Const.kt

@@ -0,0 +1,16 @@
+package com.mogo.och.shuttle.passenger.constant
+
+/**
+ * Created on 2021/12/6
+ */
+class M2Const {
+    companion object {
+        //站点UUID
+        const val M2_MAP_STATION_MAKER = "m2_map_station_maker"
+
+        /**
+         * Marker类型
+         */
+        const val TYPE_MARKER_M2_LINE = "TYPE_MARKER_M2_LINE"
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/model/PM2ADASModel.kt

@@ -0,0 +1,45 @@
+package com.mogo.och.shuttle.passenger.model
+
+import android.content.Context
+import com.mogo.och.shuttle.passenger.callback.ADASCallback
+import com.mogo.och.data.bean.BusStationBean
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/2
+ */
+class PM2ADASModel private constructor() {
+
+    private var mContext: Context? = null
+    private var mAdasCallback: ADASCallback? = null
+
+    companion object {
+        val TAG = PM2ADASModel::class.java.simpleName
+        val INSTANCE: PM2ADASModel by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
+            PM2ADASModel()
+        }
+    }
+
+    fun init(context : Context){
+        this.mContext = context
+    }
+
+    fun setAdasCallback(adasCallback: ADASCallback?){
+        this.mAdasCallback = adasCallback
+    }
+
+    fun updateHDMapStations(stations: MutableList<BusStationBean>){
+        var stationsList = mutableListOf<MutableList<Double>>()
+        for (i in stations.indices){
+            var listLatLng = mutableListOf<Double>() // 0: long 1:lat
+            listLatLng.add(stations[i].lon)
+            listLatLng.add(stations[i].lat)
+            stationsList.add(listLatLng)
+        }
+        mAdasCallback?.updateHDMapStations(stationsList)
+    }
+
+    fun removeHDMapStations(){
+        mAdasCallback?.removeHDMapStations()
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/model/PM2DrivingModel.kt

@@ -0,0 +1,628 @@
+package com.mogo.och.shuttle.passenger.model
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.net.ConnectivityManager
+import android.os.Build
+import android.os.Handler
+import androidx.annotation.RequiresApi
+import com.mogo.commons.module.intent.IMogoIntentListener
+import com.mogo.commons.module.intent.IntentManager
+import com.mogo.commons.voice.AIAssist
+import com.mogo.commons.voice.IMogoVoiceCmdCallBack
+import com.mogo.eagle.core.data.config.FunctionBuildConfig
+import com.mogo.eagle.core.data.map.MogoLocation
+import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener
+import com.mogo.eagle.core.function.api.autopilot.IMoGoChassisLocationGCJ02Listener
+import com.mogo.eagle.core.function.api.autopilot.IMoGoPlanningRottingListener
+import com.mogo.eagle.core.function.api.telematic.IReceivedMsgListener
+import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager
+import com.mogo.eagle.core.function.call.autopilot.CallerChassisLocationGCJ02ListenerManager
+import com.mogo.eagle.core.function.call.autopilot.CallerPlanningRottingListenerManager
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicListenerManager
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicManager.sendMsgToServer
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
+import com.mogo.eagle.core.utilcode.mogo.logger.Logger
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.eagle.core.utilcode.util.CoordinateUtils
+import com.mogo.eagle.core.utilcode.util.GsonUtils
+import com.mogo.eagle.core.utilcode.util.NetworkUtils
+import com.mogo.eagle.core.utilcode.util.ToastUtils
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.constant.BusPassengerConst
+import com.mogo.och.shuttle.passenger.bean.PM2OperationStatusResponse
+import com.mogo.och.shuttle.passenger.bean.PM2RoutesResponse
+import com.mogo.och.shuttle.passenger.callback.AutoPilotStatusCallback
+import com.mogo.och.shuttle.passenger.callback.DrivingInfoCallback
+import com.mogo.och.shuttle.passenger.model.PM2ServiceManager.driverAppSn
+import com.mogo.och.shuttle.passenger.network.PM2ModelLoopManager
+import com.mogo.och.common.module.bean.dpmsg.*
+import com.mogo.och.common.module.biz.common.socketmessage.OCHSocketMessageManager.pushAppOperationalMsgBox
+import com.mogo.och.common.module.biz.constant.OchCommonConst
+import com.mogo.och.common.module.biz.network.OchCommonServiceCallback
+import com.mogo.och.common.module.utils.CoordinateCalculateRouteUtil
+import com.mogo.och.common.module.utils.DateTimeUtil
+import com.mogo.och.common.module.utils.RxUtils
+import com.mogo.och.data.bean.BusRoutesResult
+import com.mogo.och.data.bean.BusStationBean
+import com.mogo.och.data.bean.BusTransferData
+import io.reactivex.disposables.Disposable
+import mogo.telematics.pad.MessagePad
+import kotlin.math.abs
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/1/31
+ */
+class PM2DrivingModel private constructor() {
+
+    private var mContext: Context? = null
+    private var mLocation: MogoLocation? = null
+
+    private var mRoutePoints = mutableListOf<MogoLocation>()
+    private var routesResult: BusRoutesResult? = null
+
+    private var mCurrentAutoStatus = -1
+
+    var mStations = mutableListOf<BusStationBean>()
+    private var mNextStationIndex = 0 // A-B要到达站的index
+    private var isGoingToNextStation = false //是否前往下一站过程中
+
+    private var mTwoStationsRouts = mutableListOf<MogoLocation>()
+    private var mPreRouteIndex = 0
+    private var mWipePreIndex = 0
+
+    private var mDrivingInfoCallback: DrivingInfoCallback? = null //行程信息
+    private var mAutoStatusCallback: AutoPilotStatusCallback? = null //自动驾驶状态
+
+    private var operationStatus: PM2OperationStatusResponse.Result? = null
+
+    @Volatile
+    private var globalPathTruncation: Disposable? = null
+
+    private val handler = Handler(Handler.Callback { msg ->
+        if (msg.what == MSG_QUERY_BUS_P_STATION) {
+            queryDriverOperationStatus()
+            return@Callback true
+        }
+        false
+    })
+
+    companion object {
+        val TAG = PM2DrivingModel::class.java.simpleName
+        const val MSG_QUERY_BUS_P_STATION = 1001
+        val INSTANCE: PM2DrivingModel by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
+            PM2DrivingModel()
+        }
+    }
+
+    fun init(context : Context){
+        mContext = context
+        initListener()
+        queryDriverByLocalDriver()
+        queryDriverOperationStatus()
+        startOrStopOrderLoop(true)
+    }
+
+    private fun queryDriverByLocalDriver() {
+        //本地去请求司机端
+        val msg = TaskDetailsMsg("task")
+        sendMsgToServer(GsonUtils.toJson(msg))
+    }
+
+    private fun initListener() {
+        //自动驾驶状态监听
+        CallerAutoPilotStatusListenerManager.addListener(TAG, mAutoPilotStatusListener)
+
+        // 定位监听
+        CallerChassisLocationGCJ02ListenerManager.addListener(TAG, 10,mMapLocationListener)
+
+        //司乘屏通信监听
+        CallerTelematicListenerManager.addListener(TAG,mReceivedMsgListener)
+
+        //自动驾驶轨迹监听
+        CallerPlanningRottingListenerManager.addListener(TAG, moGoAutopilotPlanningListener)
+
+        //网络监听
+        IntentManager.getInstance().registerIntentListener(ConnectivityManager.CONNECTIVITY_ACTION, mNetWorkIntentListener)
+
+    }
+
+    private fun sendMsgToServer(msg: String) {
+        sendMsgToServer(
+            OchCommonConst.BUSINESS_STRING,
+            GsonUtils.toJson(msg).toByteArray()
+        )
+    }
+
+    fun releaseListener(){
+        //自动驾驶状态监听
+        CallerAutoPilotStatusListenerManager.removeListener(TAG)
+
+        // 定位监听
+        CallerChassisLocationGCJ02ListenerManager.removeListener(TAG)
+
+        CallerTelematicListenerManager.removeListener(TAG)
+
+        //自动驾驶轨迹监听
+        CallerPlanningRottingListenerManager.removeListener(TAG)
+    }
+
+    fun setDrivingInfoCallback(drivingInfoCallback : DrivingInfoCallback?){
+        mDrivingInfoCallback = drivingInfoCallback
+    }
+
+    fun setAutoStatusCallback(autoPilotStatusCallback: AutoPilotStatusCallback?){
+        mAutoStatusCallback = autoPilotStatusCallback
+    }
+
+    private val mNetWorkIntentListener = IMogoIntentListener { intentStr, _ ->
+            if (ConnectivityManager.CONNECTIVITY_ACTION == intentStr) {
+                if (NetworkUtils.isConnected(mContext)) {
+                    queryDriverOperationStatus()
+                }
+            }
+        }
+
+    private val mReceivedMsgListener: IReceivedMsgListener =
+        object  : IReceivedMsgListener{
+            @RequiresApi(Build.VERSION_CODES.O)
+            override fun onReceivedMsg(type: Int, byteArray: ByteArray) {//接收司机端发来的信息
+                if (OchCommonConst.BUSINESS_STRING == type){
+                    val baseMsg = GsonUtils.fromJson(String(byteArray), BaseDPMsg::class.java)
+                    Logger.d(
+                        SceneConstant.M_BUS_P + TAG, "onReceivedMsg = " + GsonUtils.toJson(baseMsg)
+                    )
+
+                    if (baseMsg != null && baseMsg.type == DPMsgType.TYPE_COMMON.type) {
+                        val msg = GsonUtils.fromJson(String(byteArray), AppConnectMsg::class.java)
+
+                        if (msg != null && msg.isPlay){ //播报
+                            speakTTS(msg.msg)
+                        }
+
+                        if (msg != null && msg.isViewShow) { //消息盒子显示内容
+                           pushAppOperationalMsgBox(
+                                DateTimeUtil.getCurrentTimeStamp(),msg.msg)
+                        }
+                    }else if (baseMsg != null && baseMsg.type == DPMsgType.TYPE_TASK_DETAILS.type) {
+                        val msg = GsonUtils.fromJson(String(byteArray), TaskDetailsMsg::class.java)
+                        Logger.d(
+                            SceneConstant.M_BUS_P + TAG, "onReceivedMsg = " + GsonUtils.toJson(msg)
+                        )
+                        if (msg == null || msg.msg?.isEmpty() == true) {
+                            updateLocalOrder()
+                            return
+                        }
+                        val result = GsonUtils.fromJson(msg.msg, BusTransferData::class.java)
+                        mDrivingInfoCallback?.changeOperationStatus(result.loginStatus == 1)
+                        if (result != null && result.routesResult == null){
+                            updateLocalOrder()
+                        }
+
+                        if (routesResult == null ||
+                            (result != null && result.routesResult?.writeVersion!! > routesResult!!.writeVersion)) {
+                            routesResult = result.routesResult
+                            updatePassengerRouteInfo(routesResult!!)
+                        }
+
+                    }
+                }
+            }
+        }
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun speakTTS(msg: String) {
+
+        var mAudioManager = mContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        var mAudioAttributes = AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_MEDIA)	//设置声音的用途
+            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)	//设置声音的类型
+            .build()
+        var mAudioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK)	//设置焦点类型
+            .setAudioAttributes(mAudioAttributes)	//设置声音属性
+            .setAcceptsDelayedFocusGain(false)	//设置接受延迟获取焦点，需要设置OnAudioFocusChangeListener来监听焦点的获取
+            .build()
+        mAudioManager.requestAudioFocus(mAudioFocusRequest) //抢占焦点
+
+        AIAssist.getInstance(mContext).speakTTSVoiceWithLevel(msg,AIAssist.LEVEL0,object : IMogoVoiceCmdCallBack{
+            override fun onSpeakEnd(speakText: String?) {
+                mAudioManager.abandonAudioFocusRequest(mAudioFocusRequest)
+            }
+
+            override fun onSpeakError(speakText: String?, errorMsg: String?) {
+                mAudioManager.abandonAudioFocusRequest(mAudioFocusRequest)
+            }
+
+            override fun onSpeakSelectTimeOut(speakText: String?) {
+                mAudioManager.abandonAudioFocusRequest(mAudioFocusRequest)
+            }
+        })
+    }
+
+    private val mMapLocationListener: IMoGoChassisLocationGCJ02Listener =
+        object  : IMoGoChassisLocationGCJ02Listener{
+            override fun onChassisLocationGCJ02(mogoLocation: MogoLocation?) {
+                if (null == mogoLocation) return
+                mLocation = mogoLocation
+                updateSpeed(mogoLocation)
+            }
+        }
+
+    private val moGoAutopilotPlanningListener = object : IMoGoPlanningRottingListener{
+
+        @Synchronized
+        override fun onAutopilotRotting(globalPathResp: MessagePad.GlobalPathResp?) {
+            d(SceneConstant.M_BUS_P + TAG, "och-rotting==globalPathResp = " + GsonUtils.toJson(globalPathResp))
+            globalPathResp?.let {
+                d(SceneConstant.M_BUS_P + TAG, "och-rotting==wayPointsSize = " + it.wayPointsList.size)
+
+                if (globalPathTruncation != null && !globalPathTruncation!!.isDisposed) {
+                    d(SceneConstant.M_BUS_P + TAG, "1s内不可以接受轨迹")
+                    return@let
+                }
+
+                globalPathTruncation = RxUtils.createSubscribe(1_000) {
+                    d(SceneConstant.M_BUS_P + TAG, "可以接受轨迹")
+                }
+                d(SceneConstant.M_BUS_P + TAG, "接受轨迹中")
+                it.wayPointsList?.let {list->
+                    updateRoutePoints(list)
+                }
+            }
+        }
+
+    }
+
+    @Synchronized
+    fun updateRoutePoints(routePoints: List<MessagePad.Location>) {
+        mRoutePoints.clear()
+        val latLngModels = CoordinateCalculateRouteUtil
+            .coordinateConverterWgsToGcjLocations(mContext, routePoints)
+        d(SceneConstant.M_BUS_P + TAG, "och-rotting==latLngModels = " + latLngModels.size)
+        mRoutePoints.addAll(latLngModels)
+
+        if (isGoingToNextStation){
+            mTwoStationsRouts.clear()
+            startRemainRouteInfo()
+        }
+    }
+
+    private fun updateSpeed(mogoLocation: MogoLocation) {
+        // km/h
+        val speedKM = (abs(mogoLocation.gnssSpeed) * 3.6f).toInt()
+
+        mDrivingInfoCallback?.updateSpeed(speedKM)
+    }
+
+    private val mAutoPilotStatusListener: IMoGoAutopilotStatusListener =
+        object : IMoGoAutopilotStatusListener {
+
+            override fun onAutopilotStatusResponse(state: Int) {
+                super.onAutopilotStatusResponse(state)
+                d(SceneConstant.M_BUS_P+TAG, "onAutopilotStatusResponse ===== $state")
+                if (IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING != state){
+                    //美化模式下且行程中
+                    if (FunctionBuildConfig.isDemoMode &&
+                        mNextStationIndex>= 0 && mNextStationIndex <= mStations.size - 1
+                        && isGoingToNextStation){
+                        mAutoStatusCallback?.updateAutoStatus(true)
+                    }else{//非美化模式下
+                        mAutoStatusCallback?.updateAutoStatus(false)
+                    }
+                }else{//自驾状态 2
+                    mAutoStatusCallback?.updateAutoStatus(true)
+                }
+            }
+
+        }
+
+    private fun queryDriverOperationDelay() {
+        handler.sendEmptyMessageDelayed(MSG_QUERY_BUS_P_STATION,
+            BusPassengerConst.QUERY_BUS_P_STATION_DELAY
+        )
+    }
+
+    private fun queryDriverOperationStatus() {
+        mContext?.let {
+            PM2ServiceManager.queryDriverOperationStatus(
+                it,
+                object : OchCommonServiceCallback<PM2OperationStatusResponse> {
+                    override fun onSuccess(data: PM2OperationStatusResponse?) {
+                        if (data?.data == null) return
+                        if (data.data.driverStatus != operationStatus?.driverStatus
+                            || data.data.plateNumber != operationStatus?.plateNumber){
+                            d(SceneConstant.M_BUS_P+TAG, "queryDriverOperationStatus ===== 车牌或者登陆状态有变更")
+                            mDrivingInfoCallback?.changeOperationStatus(data.data.driverStatus == 1)
+                        }
+                        operationStatus = data.data as PM2OperationStatusResponse.Result
+//                        mDrivingInfoCallback?.updatePlateNumber(data.data.plateNumber)
+                    }
+
+                    override fun onError() {
+                        if (!NetworkUtils.isConnected(mContext)) {
+                            ToastUtils.showShort(mContext!!.getString(R.string.network_error_tip))
+                        } else {
+                            ToastUtils.showShort(mContext!!.getString(R.string.request_error_tip))
+                        }
+//                        queryDriverOperationDelay()
+                        queryDriverByLocalDriver()
+                    }
+
+                    override fun onFail(code: Int, msg: String) {
+                        //延迟3s再次查询
+                        queryDriverOperationDelay()
+                    }
+                })
+        }
+    }
+
+    fun queryDriverSiteByCoordinate(){
+        mContext?.let {
+            PM2ServiceManager.queryDriverSiteByCoordinate(it,
+                object : OchCommonServiceCallback<PM2RoutesResponse>{
+                    override fun onSuccess(data: PM2RoutesResponse?) {
+
+                        if (data == null || data.result == null){
+                            if (routesResult != null) {
+                                routesResult = null
+                                updateLocalOrder()
+                                d(SceneConstant.M_BUS_P+TAG, "queryDriverSiteByCoordinate= result is null")
+                                return
+                            }
+                            return
+                        }
+                        if (data.result != null && data.result.equals(routesResult)){
+                            d(SceneConstant.M_BUS_P+TAG, "queryDriverSiteByCoordinate= not update")
+                            return
+                        }
+
+                        if (routesResult != null &&
+                            routesResult!!.writeVersion < data.result.writeVersion
+                        ) {
+                            routesResult = data.result
+                        }
+
+                        if (routesResult == null) {
+                            routesResult = data.result
+                        }
+                        updatePassengerRouteInfo(data.result)
+                    }
+
+                    override fun onError() {
+                        CallerLogger.d(
+                            SceneConstant.Companion.M_BUS_P + TAG,
+                            "queryDriverSiteByCoordinate = onError ="
+                                    + ", sn = " + driverAppSn
+                        )
+                        queryDriverByLocalDriver()
+                    }
+
+                    override fun onFail(code: Int, msg: String?) {
+                        d(SceneConstant.M_BUS_P+TAG, "queryDriverSiteByCoordinate = %s", msg)
+                        if (code == 1003){
+                            queryDriverOperationDelay()
+                        }
+                        if (PM2ServiceManager.driverAppSn.isEmpty()){
+                            return
+                        }
+                        if (code == 1003) {
+                            routesResult = null
+                            isGoingToNextStation = false
+                            startOrStopCalculateRouteInfo(false)
+                            return
+                        }
+                    }
+
+                })
+        }
+    }
+
+    private fun updateLocalOrder(){
+        mRoutePoints.clear()
+        routesResult = null
+        mNextStationIndex = 0
+        isGoingToNextStation = false
+        startOrStopCalculateRouteInfo(false)
+        mDrivingInfoCallback?.showNoTaskView(true)
+    }
+
+    private fun updatePassengerRouteInfo(result: BusRoutesResult) {
+
+        if (result == null) {
+            updateLocalOrder()
+            return
+        }
+
+        if (routesResult != null && routesResult!!.lineId != result.lineId){
+            d(SceneConstant.M_BUS_P+TAG, "lineId change= clearCustomPolyline")
+            mDrivingInfoCallback?.clearCustomPolyline()
+        }
+
+        d(SceneConstant.M_BUS_P+TAG, "queryDriverSiteByCoordinate= update")
+        routesResult = result
+
+        mDrivingInfoCallback?.updateLine(result.name, result.runningDur)
+            if (result.sites != null) {
+                mDrivingInfoCallback?.showNoTaskView(false)
+                val stations: List<BusStationBean> = result.sites
+                mStations.clear()
+                mStations.addAll(stations)
+                mDrivingInfoCallback?.updateLineStations(mStations)
+                for (i in stations.indices) {
+                    val station: BusStationBean = stations[i]
+                    if (station.drivingStatus == BusPassengerConst.STATION_STATUS_STOPPED
+                        && station.isLeaving && i + 1 < stations.size) {
+                        mDrivingInfoCallback?.updateStationsInfo(stations as MutableList<BusStationBean>, i + 1, false)
+                        d(SceneConstant.M_BUS_P+TAG,"och-rotting--mNextStationIndex = $mNextStationIndex , i = $i")
+//                        if (mNextStationIndex != i + 1) {
+                            d(SceneConstant.M_BUS_P+TAG,"och-rotting--start ")
+                            mTwoStationsRouts.clear()
+                            startRemainRouteInfo()
+//                        }
+                        isGoingToNextStation = true
+                        mNextStationIndex = i + 1
+                        return
+                    } else if (station.drivingStatus == BusPassengerConst.STATION_STATUS_STOPPED && !station.isLeaving) {
+                        d(SceneConstant.M_BUS_P+TAG,"och-rotting--mNextStationIndex = $mNextStationIndex , i = $i")
+                        d(SceneConstant.M_BUS_P+TAG,"och-rotting--arrived ")
+                        mPreRouteIndex = 0
+                        isGoingToNextStation = false
+                        startOrStopCalculateRouteInfo(false)
+                        mDrivingInfoCallback?.updateStationsInfo(stations as MutableList<BusStationBean>, i, true)
+                        return
+                    }else{
+//                        d(SceneConstant.M_BUS_P+TAG,"och-rotting--BusStationBean = " + GsonUtils.toJson(station))
+                    }
+                }
+            }
+
+    }
+
+    fun loopRouteAndWipe(){
+        if (mRoutePoints != null && mRoutePoints.size > 0 && mLocation != null) {
+            val haveArrivedIndex = CoordinateCalculateRouteUtil
+                .getArrivedPointIndexNew(
+                    mWipePreIndex,
+                    mRoutePoints,
+                    mLocation!!
+                )
+            mWipePreIndex = haveArrivedIndex
+            d(SceneConstant.M_BUS_P + TAG,
+                "thread = " + Thread.currentThread().name + " haveArrivedIndex== " + haveArrivedIndex
+            )
+//            if (mAutopilotPlanningCallback != null) {
+//                val routePoints = CoordinateCalculateRouteUtil
+//                    .coordinateConverterLocationToLatLng(mContext, mRoutePoints)
+//                mAutopilotPlanningCallback.routeResult(routePoints, haveArrivedIndex)
+//            }
+        }
+    }
+
+    private fun startRemainRouteInfo() {
+        //开启实时计算剩余距离，剩余时间，预计时间
+        startOrStopCalculateRouteInfo(true)
+    }
+
+    fun dynamicCalculateRouteInfo(){
+        //计算当前位置和下一站的剩余点集合
+        //计算剩余点总里程和时间
+        d(SceneConstant.M_BUS_P + TAG, "och-rotting==mTwoStationsRouts.size() = " + mTwoStationsRouts.size)
+        //计算当前位置和下一站的剩余点集合
+        //计算剩余点总里程和时间
+        if (mTwoStationsRouts.size == 0) {
+            calculateTwoStationsRoute()
+        }
+
+        if (mTwoStationsRouts.size > 0 && mLocation != null) {
+            val lastPointsMap = CoordinateCalculateRouteUtil
+                .getRemainPointListByCompareNew(mPreRouteIndex, mTwoStationsRouts, mLocation!!)
+            for (index in lastPointsMap.keys) {
+                mPreRouteIndex = index
+                break
+            }
+            for (lastPoints in lastPointsMap.values) {
+                d(SceneConstant.M_BUS_P + TAG, "och-rotting==lastPoints.size() = " + lastPoints.size)
+                var lastSumLength = 0f
+                lastSumLength = if (lastPoints.size == 1) { //只是最后一个点，计算当前位置和最后一个点的距离
+                    if (mNextStationIndex <= mStations.size - 1 && mNextStationIndex >= 0) {
+                        val stationNext: BusStationBean = mStations[mNextStationIndex]
+                        CoordinateUtils.calculateLineDistance(
+                            stationNext.gcjLon, stationNext.gcjLat,
+                            mLocation!!.longitude, mLocation!!.latitude
+                        )
+                    } else {
+                        CoordinateUtils.calculateLineDistance(
+                            lastPoints[0].longitude, lastPoints[0].latitude,
+                            mLocation!!.longitude, mLocation!!.latitude
+                        )
+                    }
+                } else {
+                    CoordinateCalculateRouteUtil.calculateRouteSumLength(lastPoints)
+                }
+                val lastTime = lastSumLength / BusPassengerConst.SHUTTLE_AVERAGE_SPEED * 3.6 //秒
+                d(SceneConstant.M_BUS_P + TAG, "och-rotting==lastSumLength = $lastSumLength")
+                mDrivingInfoCallback?.updateRemainMT(
+                        lastSumLength.toLong(),
+                        lastTime.toLong()
+                    )
+            }
+        }
+    }
+
+    private fun calculateTwoStationsRoute() {
+        //找出前往站对应的轨迹点，拿出两站点的集合
+        d(SceneConstant.M_BUS_P + TAG, "mRoutePoints.size() = " + mRoutePoints.size)
+        if (mRoutePoints.size > 0) {
+            if (mStations.size > 1) { //两个站点及以上要计算两个站点间的轨迹路线
+                if (mNextStationIndex <= mStations.size - 1 && mNextStationIndex - 1 >= 0) {
+                    mTwoStationsRouts.clear()
+                    val stationNext: BusStationBean = mStations[mNextStationIndex]
+                    val stationCur: BusStationBean = mStations[mNextStationIndex - 1]
+                    //当前站在轨迹中对应的点
+                    val currentRouteIndex = CoordinateCalculateRouteUtil.getArrivedPointIndexNew(
+                        0, mRoutePoints, stationCur.gcjLon, stationCur.gcjLat
+                    )
+                    //要前往的站在轨迹中对应的点
+                    val nextRouteIndex = CoordinateCalculateRouteUtil.getArrivedPointIndexNew(
+                        currentRouteIndex,
+                        mRoutePoints,
+                        stationNext.gcjLon,
+                        stationNext.gcjLat
+                    )
+
+                    d(SceneConstant.M_BUS_P + TAG, "och-rotting==currentRouteIndex = " + currentRouteIndex
+                                + "， nextRouteIndex = " + nextRouteIndex)
+
+                    if (currentRouteIndex < nextRouteIndex) { //如果找到的next在起点的轨迹前面，直接舍弃这个轨迹，不显示
+                        mTwoStationsRouts.addAll(
+                            mRoutePoints.subList(
+                                currentRouteIndex,
+                                nextRouteIndex + 1
+                            )
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 开始轮询计算剩余里程和时间
+     * @param isStart
+     */
+    fun startOrStopCalculateRouteInfo(isStart: Boolean) {
+        d(SceneConstant.M_BUS_P+TAG, "startOrStopCalculateRouteInfo() $isStart")
+        if (isStart) {
+            PM2ModelLoopManager.startCalculateRouteInfoLoop()
+        } else {
+            mTwoStationsRouts.clear()
+            PM2ModelLoopManager.stopCalculateRouteInfLoop()
+        }
+    }
+
+    /**
+     * 实时轨迹擦除
+     * @param isStart
+     */
+    private fun startOrStopRouteAndWipe(isStart: Boolean) {
+        if (isStart) {
+            PM2ModelLoopManager.startOrStopRouteAndWipe()
+        } else {
+            mWipePreIndex = 0
+            PM2ModelLoopManager.stopOrStopRouteAndWipe()
+        }
+    }
+
+    private fun startOrStopOrderLoop(start: Boolean) {
+        d(SceneConstant.M_BUS_P + TAG, "startOrStopOrderLoop() $start")
+        if (start) {
+            PM2ModelLoopManager.startQueryDriverLineLoop()
+        } else {
+            PM2ModelLoopManager.stopQueryDriverLineLoop()
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/model/PM2ServiceManager.kt

@@ -0,0 +1,77 @@
+package com.mogo.och.shuttle.passenger.model
+
+import android.content.Context
+import com.mogo.eagle.core.function.call.telematic.CallerTelematicManager.getServerToken
+import com.mogo.cloud.passport.MoGoAiCloudClientConfig
+import com.mogo.eagle.core.network.MoGoRetrofitFactory
+import com.mogo.och.shuttle.passenger.bean.PM2OperationStatusResponse
+import com.mogo.och.shuttle.passenger.bean.PM2QueryLineRequest
+import com.mogo.och.shuttle.passenger.bean.PM2RoutesResponse
+import com.mogo.och.shuttle.passenger.network.PM2ServiceApi
+import com.mogo.och.common.module.biz.constant.OchCommonConst
+import com.mogo.och.common.module.biz.network.OchCommonServiceCallback
+import com.mogo.och.common.module.biz.network.OchCommonSubscribeImpl
+import com.mogo.och.common.module.biz.network.interceptor.transformTry
+
+/**
+ * Created on 2022/3/31
+ */
+object PM2ServiceManager {
+
+    private var mBusPassengerServiceApi =
+        MoGoRetrofitFactory.getInstance(OchCommonConst.getShuttleUrl()).create(PM2ServiceApi::class.java)
+
+    private var driverSnCache = ""
+    /**
+     * 获取Bus司机端的sn
+     * @return
+     */
+    public val driverAppSn: String
+        get(){
+            val serverToken = getServerToken()
+            if (serverToken != driverSnCache && serverToken.isNotEmpty()) {
+                driverSnCache = serverToken
+            }
+            return driverSnCache
+        }
+
+    /**
+     * 查询绑定行驶的小巴车路线
+     * @param context
+     * @param callback
+     */
+    @JvmStatic
+    fun queryDriverSiteByCoordinate(
+        context: Context, callback: OchCommonServiceCallback<PM2RoutesResponse>?
+    ) {
+        mBusPassengerServiceApi.queryDriverSiteByCoordinate(
+            MoGoAiCloudClientConfig.getInstance().serviceAppId,
+            MoGoAiCloudClientConfig.getInstance().token,
+            PM2QueryLineRequest(
+                driverAppSn
+            )
+        ).transformTry()
+            .subscribe(OchCommonSubscribeImpl(context, callback, "queryDriverSiteByCoordinate=sn =$driverAppSn"))
+
+    }
+
+    /**
+     * 查询司机端出车收车状态，以及车牌号
+     * @param context
+     * @param callback
+     */
+    @JvmStatic
+    fun queryDriverOperationStatus(
+        context: Context,
+        callback: OchCommonServiceCallback<PM2OperationStatusResponse>?
+    ) {
+        mBusPassengerServiceApi.queryDriverOperationStatus(
+            MoGoAiCloudClientConfig.getInstance().serviceAppId,
+            MoGoAiCloudClientConfig.getInstance().token,
+            driverAppSn
+        )
+            .transformTry()
+            .subscribe(OchCommonSubscribeImpl(context, callback, "queryDriverOperationStatus=sn =$driverAppSn"))
+
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/network/PM2ModelLoopManager.kt

@@ -0,0 +1,127 @@
+package com.mogo.och.shuttle.passenger.network
+
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.i
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.och.shuttle.passenger.constant.BusPassengerConst
+import com.mogo.och.shuttle.passenger.model.PM2DrivingModel
+import io.reactivex.Observable
+import io.reactivex.ObservableOnSubscribe
+import io.reactivex.android.schedulers.AndroidSchedulers
+import io.reactivex.disposables.CompositeDisposable
+import io.reactivex.disposables.Disposable
+import io.reactivex.schedulers.Schedulers
+import java.util.concurrent.TimeUnit
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/1
+ */
+object PM2ModelLoopManager {
+
+    private val TAG: String = PM2ModelLoopManager::class.java.getSimpleName()
+
+    private var mQueryLineDisposable: Disposable? = null   //心跳轮询
+    private var mRouteWipeDisposable: CompositeDisposable? = null  //估计擦除
+    private var mCalculateRouteDisposable: CompositeDisposable? = null //每隔2s计算一次剩余里程和时间
+
+
+    fun startOrStopRouteAndWipe() {
+        i(SceneConstant.M_BUS_P + TAG, "startOrStopRouteWipe()")
+        if (mRouteWipeDisposable != null) return
+        if (mRouteWipeDisposable == null) {
+            mRouteWipeDisposable = CompositeDisposable()
+        }
+        val disposable = startLoopRouteAndWipe()
+            .doOnSubscribe { }
+            .doOnError { }
+            .delay(
+                BusPassengerConst.LOOP_LINE_1S,
+                TimeUnit.MILLISECONDS,
+                true
+            ) // 设置delayError为true，表示出现错误的时候也需要延迟5s进行通知，达到无论是请求正常还是请求失败，都是5s后重新订阅，即重新请求。
+            .subscribeOn(Schedulers.io())
+            .repeat() // repeat保证请求成功后能够重新订阅。
+            .retry() // retry保证请求失败后能重新订阅
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribe { }
+        mRouteWipeDisposable!!.add(disposable)
+    }
+
+    fun stopOrStopRouteAndWipe() {
+        if (mRouteWipeDisposable != null) {
+            mRouteWipeDisposable!!.dispose()
+            mRouteWipeDisposable = null
+        }
+    }
+
+    fun startQueryDriverLineLoop() {
+        if (mQueryLineDisposable != null && !mQueryLineDisposable!!.isDisposed) {
+            return
+        }
+        i(SceneConstant.M_BUS_P + TAG, "startQueryDriverLineLoop()")
+        mQueryLineDisposable = Observable.interval(
+            BusPassengerConst.LOOP_DELAY,
+            BusPassengerConst.LOOP_LINE_2S, TimeUnit.MILLISECONDS
+        )
+            .map { aLong: Long -> aLong + 1 }
+            .subscribeOn(Schedulers.io())
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribe { aLong: Long? ->
+                PM2DrivingModel.INSTANCE.queryDriverSiteByCoordinate()
+            }
+    }
+
+    fun stopQueryDriverLineLoop() {
+        if (mQueryLineDisposable != null) {
+            i(SceneConstant.M_BUS_P + TAG, "stopQueryDriverLineLoop()")
+            mQueryLineDisposable!!.dispose()
+            mQueryLineDisposable = null
+        }
+    }
+
+    fun startCalculateRouteInfoLoop() {
+        i(SceneConstant.M_BUS_P + TAG, "startCalculateRouteInfoLoop()")
+        if (mCalculateRouteDisposable != null) return
+        if (mCalculateRouteDisposable == null) {
+            mCalculateRouteDisposable = CompositeDisposable()
+        }
+        val disposable = startLoopCalculateRouteInfo()
+            .doOnSubscribe { }
+            .doOnError { }
+            .delay(
+                BusPassengerConst.LOOP_LINE_2S,
+                TimeUnit.MILLISECONDS,
+                true
+            ) // 设置delayError为true，表示出现错误的时候也需要延迟5s进行通知，达到无论是请求正常还是请求失败，都是5s后重新订阅，即重新请求。
+            .subscribeOn(Schedulers.io())
+            .repeat() // repeat保证请求成功后能够重新订阅。
+            .retry() // retry保证请求失败后能重新订阅
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribe { }
+        mCalculateRouteDisposable!!.add(disposable)
+    }
+
+    fun stopCalculateRouteInfLoop() {
+        if (mCalculateRouteDisposable != null) {
+            i(SceneConstant.M_BUS_P + TAG, "stopCalculateRouteInfLoop()")
+            mCalculateRouteDisposable!!.dispose()
+            mCalculateRouteDisposable = null
+        }
+    }
+
+    private fun startLoopRouteAndWipe(): Observable<Int?> {
+        return Observable.create(ObservableOnSubscribe { emitter ->
+            if (emitter.isDisposed) return@ObservableOnSubscribe
+            PM2DrivingModel.INSTANCE.loopRouteAndWipe()
+            emitter.onComplete()
+        })
+    }
+
+    private fun startLoopCalculateRouteInfo(): Observable<Int?> {
+        return Observable.create(ObservableOnSubscribe { emitter ->
+            if (emitter.isDisposed) return@ObservableOnSubscribe
+            PM2DrivingModel.INSTANCE.dynamicCalculateRouteInfo()
+            emitter.onComplete()
+        })
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/network/PM2ServiceApi.java

@@ -0,0 +1,40 @@
+package com.mogo.och.shuttle.passenger.network;
+
+import com.mogo.och.shuttle.passenger.bean.PM2OperationStatusResponse;
+import com.mogo.och.shuttle.passenger.bean.PM2QueryLineRequest;
+import com.mogo.och.shuttle.passenger.bean.PM2RoutesResponse;
+
+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 on 2022/3/31
+ *
+ * Bus乘客端接口定义
+ */
+public interface PM2ServiceApi {
+    /**
+     * 查询bus司机端绑定路线
+     * @return 接口返回数据
+     */
+    @Headers( {"Content-Type:application/json;charset=UTF-8"} )
+    @POST( "/och-shuttle-cabin/api/business/v1/passenger/lineDataWithDriver/query" )
+    Observable<PM2RoutesResponse> queryDriverSiteByCoordinate(@Header("appId") String appId, @Header("ticket") String ticket, @Body PM2QueryLineRequest request);
+
+    /**
+     * 查询司机端的登陆状态
+     * @param sn
+     * @return
+     */
+    @Headers({"Content-type:application/json;charset=UTF-8"})
+//    @GET("/autopilot-car-hailing/car/v2/driver/bus/passenger/takeOrderStatus/query")
+    @GET("/och-shuttle-cabin/api/business/v1/passenger/loginStatus")
+    Observable<PM2OperationStatusResponse> queryDriverOperationStatus(@Header ("appId") String appId, @Header("ticket") String ticket, @Query("sn") String sn);
+
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/presenter/PM2ADASPresenter.kt

@@ -0,0 +1,41 @@
+package com.mogo.och.shuttle.passenger.presenter
+
+import androidx.lifecycle.LifecycleOwner
+import com.mogo.commons.mvp.Presenter
+import com.mogo.och.shuttle.passenger.callback.ADASCallback
+import com.mogo.och.shuttle.passenger.constant.M2Const.Companion.M2_MAP_STATION_MAKER
+import com.mogo.och.shuttle.passenger.model.PM2ADASModel
+import com.mogo.och.shuttle.passenger.ui.PM2HPMapFragment
+
+class PM2ADASPresenter(view: PM2HPMapFragment?) :
+    Presenter<PM2HPMapFragment?>(view), ADASCallback {
+
+    init {
+            PM2ADASModel.INSTANCE.init(context)
+            initListener()
+    }
+
+    private fun initListener() {
+        PM2ADASModel.INSTANCE.setAdasCallback(this)
+    }
+
+    private fun removeListener() {
+        PM2ADASModel.INSTANCE.setAdasCallback(null)
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+        super.onDestroy(owner)
+        removeListener()
+    }
+
+    override fun updateHDMapStations(stations: MutableList<MutableList<Double>>) {
+        for (i in stations.indices){
+            mView?.setMapMaker(M2_MAP_STATION_MAKER+i,stations[i])
+        }
+
+    }
+
+    override fun removeHDMapStations() {
+        mView?.removeMapMaker(M2_MAP_STATION_MAKER)
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/presenter/PM2DrivingPresenter.kt

@@ -0,0 +1,143 @@
+package com.mogo.och.shuttle.passenger.presenter
+
+import androidx.lifecycle.LifecycleOwner
+import com.amap.api.maps.model.LatLng
+import com.mogo.commons.mvp.Presenter
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.och.shuttle.passenger.callback.AutoPilotStatusCallback
+import com.mogo.och.shuttle.passenger.callback.DrivingInfoCallback
+import com.mogo.och.shuttle.passenger.model.PM2ADASModel
+import com.mogo.och.shuttle.passenger.model.PM2DrivingModel
+import com.mogo.och.shuttle.passenger.ui.PM2DrivingInfoFragment
+import com.mogo.och.data.bean.BusStationBean
+
+class PM2DrivingPresenter(view: PM2DrivingInfoFragment?) :
+    Presenter<PM2DrivingInfoFragment?>(view), DrivingInfoCallback, AutoPilotStatusCallback {
+
+    init {
+        PM2DrivingModel.INSTANCE.init(context)
+        PM2ADASModel.INSTANCE.init(context)
+        initListener()
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+        super.onDestroy(owner)
+        destroyListener()
+        PM2DrivingModel.INSTANCE.releaseListener()
+    }
+
+    private fun initListener(){
+        PM2DrivingModel.INSTANCE.setDrivingInfoCallback(this)
+        PM2DrivingModel.INSTANCE.setAutoStatusCallback(this)
+    }
+
+    private fun  destroyListener(){
+        PM2DrivingModel.INSTANCE.setDrivingInfoCallback(null)
+        PM2DrivingModel.INSTANCE.setAutoStatusCallback(null)
+    }
+
+    override fun updateSpeed(speed: Int) {
+//        CallerLogger.d(
+//            SceneConstant.M_BUS_P + "speed = ",speed.toString()
+//        )
+        ThreadUtils.runOnUiThread {
+            mView?.updateSpeed(speed)
+        }
+    }
+
+    override fun updatePlateNumber(carNum: String) {
+        ThreadUtils.runOnUiThread {
+            mView?.updateCarPlateNum(carNum)
+        }
+    }
+
+    override fun updateLine(lineName: String, lineDuring: String) {
+        ThreadUtils.runOnUiThread {
+            mView?.updateTaskName(lineName)
+            mView?.updateTaskDuringTime(lineDuring)
+        }
+    }
+
+    override fun updateRemainMT(meters: Long, timeInSecond: Long) {
+        ThreadUtils.runOnUiThread {
+            mView?.updateRemainMT(meters, timeInSecond) //米，秒
+        }
+    }
+
+    override fun changeOperationStatus(loginStatus: Boolean) {
+        ThreadUtils.runOnUiThread {
+            mView?.changeOperationStatus(loginStatus)
+        }
+    }
+
+    override fun showNoTaskView(isTrue: Boolean) {
+        ThreadUtils.runOnUiThread {
+            mView?.showNoTaskView(!isTrue)
+        }
+        if (isTrue){
+            PM2ADASModel.INSTANCE.removeHDMapStations()
+        }
+    }
+
+    override fun updateLineStations(stations: MutableList<BusStationBean>) {
+
+        val stationsList = mutableListOf<LatLng>()
+        val stationsListPass = mutableListOf<LatLng>()
+        var startStation: LatLng? = null
+        var endStation: LatLng? = null
+
+        for (i in stations.indices){
+            val station = stations[i]
+            val latLng = LatLng(station.gcjLat,station.gcjLon)
+            if(i==0){
+                startStation = latLng
+                    continue
+            }
+            if(i==stations.size-1){
+                endStation = latLng
+                continue
+            }
+            if(station.drivingStatus==1){//行驶信息，0初始值；1已经过；2当前站；3未到站
+                stationsListPass.add(latLng)
+            }else if(station.drivingStatus==2){
+                if(station.isLeaving){
+                    stationsListPass.add(latLng)
+                }else{
+                    stationsList.add(latLng)
+                }
+            }else{
+                stationsList.add(latLng)
+            }
+
+        }
+
+        ThreadUtils.runOnUiThread {
+            mView?.updateLineStations(stationsList,stationsListPass,startStation,endStation)
+        }
+        PM2ADASModel.INSTANCE.updateHDMapStations(stations)
+    }
+
+    override fun updateStationsInfo(stations: MutableList<BusStationBean>, i: Int, isArrived: Boolean) {
+        ThreadUtils.runOnUiThread {
+            mView?.updateStationsInfo(stations,i,isArrived)
+        }
+    }
+
+    override fun clearCustomPolyline() {
+        ThreadUtils.runOnUiThread {
+            mView?.clearCustomPolyline()
+        }
+    }
+
+    override fun updateAutoStatus(isOpen: Boolean) {
+        ThreadUtils.runOnUiThread {
+            mView?.updateAutoStatus(isOpen)
+        }
+    }
+
+    override fun updateAutoStatus(status: Int) {
+
+    }
+
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/presenter/PM2Presenter.kt

@@ -0,0 +1,7 @@
+package com.mogo.och.shuttle.passenger.presenter
+
+import com.mogo.commons.mvp.Presenter
+import com.mogo.och.shuttle.passenger.ui.PM2BaseFragment
+
+class PM2Presenter(view: PM2BaseFragment?) :
+    Presenter<PM2BaseFragment?>(view)

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/presenter/PM2VideoPresenter.kt

@@ -0,0 +1,7 @@
+package com.mogo.och.shuttle.passenger.presenter
+
+import com.mogo.commons.mvp.Presenter
+import com.mogo.och.shuttle.passenger.ui.video.PM2VideoFragment
+
+class PM2VideoPresenter(view: PM2VideoFragment?) :
+    Presenter<PM2VideoFragment?>(view)

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/provider/M2StatusViewManager.java

@@ -0,0 +1,33 @@
+package com.mogo.och.shuttle.passenger.provider;
+
+import android.content.Context;
+import android.view.View;
+
+import com.mogo.och.shuttle.passenger.ui.widget.M2StatusBarView;
+import androidx.annotation.NonNull;
+
+import com.alibaba.android.arouter.facade.annotation.Route;
+import com.mogo.eagle.core.data.constants.MogoServicePaths;
+import com.mogo.eagle.core.function.api.hmi.view.IStatusViewLayout;
+
+/**
+ * @author congtaowang
+ * @since 2020-01-06
+ * <p>
+ * 根据优先级控制显示 window view.
+ */
+@Route( path = MogoServicePaths.PATH_STATUS_VIEW_MANAGER )
+public class M2StatusViewManager implements IStatusViewLayout {
+
+
+    @NonNull
+    @Override
+    public View getStatusView(Context context) {
+        return new M2StatusBarView(context);
+    }
+
+    @Override
+    public void init(Context context) {
+
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/PM2BaseFragment.kt

@@ -0,0 +1,70 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import com.mogo.commons.mvp.MvpFragment
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.presenter.PM2Presenter
+import com.mogo.och.shuttle.passenger.ui.video.PM2VideoFragment
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/12
+ */
+class PM2BaseFragment :
+    MvpFragment<PM2BaseFragment?, PM2Presenter?>() {
+
+    private var drivingFragment : PM2DrivingInfoFragment? = null
+    private var hdMapFragment : PM2HPMapFragment? = null
+    private var videoFragment : PM2VideoFragment? = null
+
+    override fun getLayoutId(): Int {
+        return R.layout.shuttle_p_m2_fragment
+    }
+
+    override fun getTagName(): String {
+        return TAG
+    }
+
+    override fun initViews() {
+        //横竖屏
+//        setScreenDirection()
+
+        //隐藏小地图
+        initFragment()
+    }
+
+//    private fun setScreenDirection() {
+//        var ro = Settings.System.getInt(context?.contentResolver,
+//            Settings.System.USER_ROTATION,Surface.ROTATION_270)
+//        if (ro != Surface.ROTATION_270){
+//            ro = Surface.ROTATION_270
+//        }
+//       Settings.System.putInt(context?.contentResolver,
+//           Settings.System.USER_ROTATION,ro)
+//    }
+
+    /**
+     * 初始化行程信息，高静地图，宣传 三个fragment
+     */
+    private fun initFragment() {
+
+        if (drivingFragment == null) drivingFragment = PM2DrivingInfoFragment()
+        childFragmentManager.beginTransaction().add(R.id.driving_fragment, drivingFragment!!)
+            .show(drivingFragment!!).commitAllowingStateLoss()
+
+        if (hdMapFragment == null) hdMapFragment = PM2HPMapFragment()
+        childFragmentManager.beginTransaction().add(R.id.hd_map_fragment, hdMapFragment!!)
+            .show(hdMapFragment!!).commitAllowingStateLoss()
+
+        if (videoFragment == null) videoFragment = PM2VideoFragment()
+        childFragmentManager.beginTransaction().add(R.id.video_fragment, videoFragment!!)
+            .show(videoFragment!!).commitAllowingStateLoss()
+    }
+
+    override fun createPresenter(): PM2Presenter {
+        return PM2Presenter(this)
+    }
+
+    companion object {
+        public val TAG = PM2BaseFragment::class.java.simpleName
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/PM2DrivingInfoFragment.kt

@@ -0,0 +1,300 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import android.graphics.BitmapFactory
+import android.graphics.drawable.AnimationDrawable
+import android.os.Bundle
+import android.view.View
+import androidx.core.content.ContextCompat
+import com.amap.api.maps.model.LatLng
+import com.mogo.commons.AbsMogoApplication
+import com.mogo.commons.mvp.MvpFragment
+import com.mogo.eagle.core.function.hmi.ui.setting.ToggleDebugView
+import com.mogo.eagle.core.function.view.SiteMarkerBean
+import com.mogo.eagle.core.widget.media.video.TextureVideoViewOutlineProvider
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.presenter.PM2DrivingPresenter
+import com.mogo.och.common.module.utils.DateTimeUtil.*
+import com.mogo.och.common.module.utils.NumberFormatUtil
+import com.mogo.och.data.bean.BusStationBean
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.auto_tv
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.clg_distance_left_time
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.group_not_select_line
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.group_stationinfo
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.iv_animal_list
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.line_during_tv
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.line_name_tv
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.overMapView
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.speed_tv
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.station_name_tv
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.tv_arrived_notice
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.tv_distance
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.tv_left_time
+import kotlinx.android.synthetic.main.shuttle_p_m2_driving_info_fragment.tv_next_station_title
+
+import me.jessyan.autosize.utils.AutoSizeUtils
+import kotlin.math.ceil
+import kotlin.math.roundToInt
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/12
+ */
+class PM2DrivingInfoFragment :
+    MvpFragment<PM2DrivingInfoFragment?, PM2DrivingPresenter?>() {
+
+    val stationIcon = BitmapFactory.decodeResource(AbsMogoApplication.getApp().resources, R.drawable.shuttle_p_m2_map_staton_icon)
+    val stationPassIcon = BitmapFactory.decodeResource(AbsMogoApplication.getApp().resources, R.drawable.shuttle_p_m2_map_staton_arrived_icon)
+    val startStationIcon = BitmapFactory.decodeResource(AbsMogoApplication.getApp().resources, R.drawable.shuttle_p_m2_map_start_icon)
+    val endStationIcon = BitmapFactory.decodeResource(AbsMogoApplication.getApp().resources, R.drawable.shuttle_p_m2_map_end_icon)
+
+    /**
+     * 改变自动驾驶状态
+     *
+     * @param status 2 - running  1 - enable  2 - disable
+     */
+    override fun getLayoutId(): Int {
+        return R.layout.shuttle_p_m2_driving_info_fragment
+    }
+
+    override fun getTagName(): String {
+        return TAG
+    }
+
+    override fun initViews() {
+        speed_tv.setOnLongClickListener {
+            context?.let { ToggleDebugView.toggleDebugView.toggle(it) }
+            true
+        }
+
+        line_name_tv.setTextColor(resources.getColor(R.color.shuttle_p_m2_line_name_tv_color))
+        station_name_tv.setTextColor(resources.getColor(R.color.shuttle_p_m2_line_name_tv_color))
+        speed_tv.setVertrial(true)
+        val intArrayOf = intArrayOf(
+            requireContext().resources.getColor(R.color.shuttle_p_m2_color_43cefe),
+            requireContext().resources.getColor(R.color.shuttle_p_m2_color_1466fb)
+        )
+        speed_tv.setmColorList(intArrayOf)
+
+//        current_time_tv.onClick {
+
+//            //测试V2X消息
+//            CallerMsgBoxManager.saveMsgBox(
+//                MsgBoxBean(
+//                    MsgBoxType.V2X,
+//                    V2XMsg(
+//                        "6666",
+//                        "超速行驶",
+//                        ""
+//                    )
+//                )
+//            )
+//
+//            val noticeTrafficStylePushData = NoticeTrafficStylePushData()
+//            noticeTrafficStylePushData.content= "测试公告布局"
+//            val noticeFromCloudMsg = NoticeFrCloudMsg(null, noticeTrafficStylePushData, 1)
+//            CallerMsgBoxManager.saveMsgBox(
+//                MsgBoxBean(
+//                    MsgBoxType.NOTICE, noticeFromCloudMsg)
+//            )
+//            BPRouteDataTestUtils.converToRouteData()
+//        }
+    }
+
+    override fun initViews(savedInstanceState: Bundle?) {
+        super.initViews(savedInstanceState)
+        overMapView?.let {
+            it.onCreateView(savedInstanceState)
+            val radius = AutoSizeUtils.dp2px(requireContext(), 16f)
+            it.outlineProvider = TextureVideoViewOutlineProvider(radius.toFloat())
+            it.clipToOutline = true
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        overMapView?.let{
+            it.onResume()
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        overMapView?.let{
+            it.onPause()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        overMapView?.let{
+            it.onDestroy()
+        }
+    }
+
+    fun updateSpeed(speed: Int){
+        speed_tv.text = speed.toString()
+    }
+
+    fun updateCarPlateNum(plateNum : String){
+
+    }
+
+    fun updateTaskName(name: String){
+        line_name_tv.text = name
+    }
+
+    fun updateTaskDuringTime(time : String){
+        line_during_tv.text = time
+    }
+
+    fun changeOperationStatus(status:Boolean){
+        if (!status){
+            updateNoOrderUI()
+        }
+    }
+
+    fun showNoTaskView(haveTask: Boolean){
+        setLineInfoView(haveTask)
+    }
+
+    private fun setLineInfoView(isShow: Boolean){
+        if (!isShow){
+            updateNoOrderUI()
+        }
+    }
+
+    private fun updateNoOrderUI() {
+        line_name_tv.text = resources.getString(R.string.shuttle_p_m2_not_select_line_content)
+        updateNoStationView()
+        overMapView?.let {
+            it.clearSiteMarkers()
+        }
+        clearCustomPolyline()
+    }
+
+    fun clearCustomPolyline(){
+        overMapView?.let {
+            it.clearCustomPolyline()
+        }
+    }
+    private fun updateNoStationView(){
+        station_name_tv.setTextColor(resources.getColor(R.color.shuttle_p_m2_next_tv_color))
+        station_name_tv.text = resources.getString(R.string.shuttle_p_m2_empty_tv)
+        tv_distance.text = resources.getString(R.string.shuttle_p_m2_empty_remain_km)
+        tv_left_time.text = resources.getString(R.string.shuttle_p_m2_empty_remain_minute)
+        noLineShow()
+    }
+
+    override fun createPresenter(): PM2DrivingPresenter {
+        return PM2DrivingPresenter(this)
+    }
+
+    fun updateAutoStatus(isAutoPilot: Boolean) {
+        if (isAutoPilot){
+            context?.let { auto_tv.setTextColor(ContextCompat.getColor(it,R.color.shuttle_p_m2_white_color)) }
+            context?.let { auto_tv.background = ContextCompat.getDrawable(it,R.drawable.shuttle_p_m2_auto_button_bg) }
+        }else{
+            context?.let { auto_tv.setTextColor(ContextCompat.getColor(it,R.color.shuttle_p_m2_color_7094ad)) }
+            context?.let { auto_tv.background = ContextCompat.getDrawable(it,R.drawable.shuttle_p_m2_bg_p_m2_auto) }
+        }
+    }
+
+    fun updateLineStations(
+        stations: MutableList<LatLng>,
+        stationsPass: MutableList<LatLng>,
+        startStation: LatLng?,
+        endStation: LatLng?
+    ){
+        overMapView?.let {
+            val stationsList: MutableList<SiteMarkerBean> = mutableListOf()
+            startStation?.let { start->
+                stationsList.add(SiteMarkerBean(start,startStationIcon,0.5f,0.5f))
+            }
+            for (stationsPass in stationsPass) {
+                stationsList.add(SiteMarkerBean(stationsPass,stationPassIcon,0.5f,0.5f))
+            }
+            for (stationsPass in stations) {
+                stationsList.add(SiteMarkerBean(stationsPass,stationIcon,0.5f,0.5f))
+            }
+            endStation?.let {end->
+                stationsList.add(SiteMarkerBean(end,endStationIcon,0.5f,0.5f))
+            }
+            it.drawSiteMarkers(stationsList)
+        }
+    }
+
+    fun updateStationsInfo(stations: MutableList<BusStationBean>, i: Int, isArrived: Boolean){
+        if (stations.size == 0) return
+        if (0<= i && i<stations.size){
+            station_name_tv.setTextColor(resources.getColor(R.color.shuttle_p_m2_next_tv_color))
+            station_name_tv.text  = stations[i].name
+        }
+        if (isArrived){//到站
+            tv_distance.text = resources.getString(R.string.shuttle_p_m2_empty_remain_km)
+            tv_left_time.text = resources.getString(R.string.shuttle_p_m2_empty_remain_minute)
+            tv_next_station_title.text = resources.getString(R.string.shuttle_p_m2_station_title_arrived_tv)
+            haveLineAndArrivedStation()
+        }else{ //前往目的地中
+            tv_next_station_title.text = resources.getString(R.string.shuttle_p_m2_next_station_title)
+            haveLineAndArriveingStation()
+        }
+    }
+
+    /**
+     * 剩余里程和时间
+     */
+    fun updateRemainMT(meters: Long, timeInSecond: Long) { //米。秒
+        var disUnit = "公里"
+        var remainDis: String? = "0"
+
+        if (meters > 0) {
+            if (meters / 1000 < 1) {
+                disUnit = "米"
+                remainDis = meters.toFloat().roundToInt().toString()
+            } else {
+                disUnit = "公里"
+                remainDis = NumberFormatUtil.formatLong(meters.toDouble() / 1000)
+            }
+        }
+
+        val time = ceil(timeInSecond / 60f).toInt()
+
+        "$remainDis$disUnit".also { tv_distance.text = it }
+        "${time}分钟".also { tv_left_time.text = it }
+    }
+
+    fun noLineShow(){
+        // 没有线路展示
+        group_not_select_line.visibility = View.VISIBLE
+        // 下一个站点
+        group_stationinfo.visibility = View.GONE
+        // 距离和剩余大概时间
+        clg_distance_left_time.visibility = View.GONE
+        // 到达站点
+        tv_arrived_notice.visibility = View.GONE
+
+        iv_animal_list.visibility = View.GONE
+    }
+    // 有线路正在到站点
+    fun haveLineAndArriveingStation(){
+        group_not_select_line.visibility = View.GONE
+        group_stationinfo.visibility = View.VISIBLE
+        clg_distance_left_time.visibility = View.VISIBLE
+        tv_arrived_notice.visibility = View.GONE
+        iv_animal_list.visibility = View.GONE
+    }
+    // 有线路到达站点
+    private fun haveLineAndArrivedStation(){
+        group_not_select_line.visibility = View.GONE
+        group_stationinfo.visibility = View.VISIBLE
+        clg_distance_left_time.visibility = View.GONE
+        tv_arrived_notice.visibility = View.VISIBLE
+        iv_animal_list.visibility = View.VISIBLE
+        val animationDrawable = iv_animal_list.drawable as AnimationDrawable
+        animationDrawable.start()
+    }
+
+    companion object {
+        private val TAG = PM2DrivingInfoFragment::class.java.simpleName
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/PM2HPMapFragment.kt

@@ -0,0 +1,127 @@
+package com.mogo.och.shuttle.passenger.ui
+
+import android.os.Bundle
+import com.mogo.commons.mvp.MvpFragment
+import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager.getOverlayManager
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
+import com.mogo.map.overlay.core.Level
+import com.mogo.map.overlay.point.Point
+import com.mogo.map.MapDataWrapper
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.constant.M2Const.Companion.TYPE_MARKER_M2_LINE
+import com.mogo.och.shuttle.passenger.presenter.PM2ADASPresenter
+import com.mogo.och.common.module.utils.OCHThreadPoolManager
+import kotlinx.android.synthetic.main.shuttle_p_m2_hpmap_fragment.mapBizView
+
+import java.util.*
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/12
+ */
+class PM2HPMapFragment :
+    MvpFragment<PM2HPMapFragment?, PM2ADASPresenter?>() {
+    /**
+     * 改变自动驾驶状态
+     *
+     * @param status 2 - running  1 - enable  2 - disable
+     */
+    override fun getLayoutId(): Int {
+        return R.layout.shuttle_p_m2_hpmap_fragment
+    }
+
+    override fun getTagName(): String {
+        return TAG
+    }
+
+    override fun initViews() {
+    }
+
+    override fun initViews(savedInstanceState: Bundle?) {
+        super.initViews(savedInstanceState)
+        mapBizView.onCreate(savedInstanceState)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        mapBizView.onResume()
+    }
+
+    override fun onLowMemory() {
+        super.onLowMemory()
+        mapBizView.onLowMemory()
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        mapBizView.onSaveInstanceState(outState)
+    }
+
+    override fun onPause() {
+        super.onPause()
+        mapBizView.onPause()
+    }
+
+    override fun onDestroyView() {
+        mapBizView.onDestroy()
+        super.onDestroyView()
+    }
+
+    override fun createPresenter(): PM2ADASPresenter {
+        return PM2ADASPresenter(this)
+    }
+
+    companion object {
+        private val TAG = PM2HPMapFragment::class.java.simpleName
+    }
+
+    fun setMapMaker(
+        uuid: String,
+        station: MutableList<Double>,
+    ) {
+        //开启线程执行起终点marker设置
+        val setMapMarkerRunnable = Runnable {
+            d(
+                "setMapMaker= " + Thread.currentThread().name,
+                uuid + "=latitude=" + station[1] + ",longitude=" + station[0]
+            )
+
+            val builder = Point.Options.Builder(
+                TYPE_MARKER_M2_LINE,
+                Level.MAP_MARKER
+            )
+                .setId(uuid)
+                .anchor(0.5f, 0.5f)
+                .set3DMode(true)
+                .isUseGps(true)
+                .controlAngle(true)
+                .icon3DRes(R.raw.star_marker)
+                .longitude(station[0])
+                .latitude(station[1])
+            MapDataWrapper.getCenterLineInfo(
+                station[0], station[1], -1f
+            ) {
+                // 有可能鹰眼map为空没有角度。判空使用后可能造成maker角度跟道路角度不一致 地图未初始化会返回空
+                it?.let{
+                    builder.rotate(it.angle.toFloat())
+                }
+            }
+            val overlayManager = getOverlayManager()
+            overlayManager?.showOrUpdatePoint(builder.build())
+        }
+        OCHThreadPoolManager.getsInstance().execute(setMapMarkerRunnable)
+    }
+
+    fun removeMapMaker(
+        uuid: String,
+    ) {
+        //开启线程移除起终点marker设置
+        val removeMapMarkerRunnable = Runnable {
+            d("RemoveMapMaker=" + Thread.currentThread().name, uuid)
+            val overlayManager = getOverlayManager()
+            overlayManager?.removeAllPointsInOwner(TYPE_MARKER_M2_LINE)
+        }
+        OCHThreadPoolManager.getsInstance().execute(removeMapMarkerRunnable)
+    }
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/video/PM2VideoFragment.kt

@@ -0,0 +1,64 @@
+package com.mogo.och.shuttle.passenger.ui.video
+
+import com.google.gson.reflect.TypeToken
+import com.mogo.commons.mvp.MvpFragment
+import com.mogo.eagle.core.data.config.FunctionBuildConfig
+import com.mogo.eagle.core.utilcode.util.GsonUtils
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.shuttle.passenger.presenter.PM2VideoPresenter
+import com.mogo.och.common.module.wigets.video.AdsDatas
+import com.mogo.och.common.module.wigets.video.RotationItem
+import kotlinx.android.synthetic.main.shuttle_p_m2_video_fragment.imageVideoRotationView
+
+/**
+ * @author: wangmingjun
+ * @date: 2022/4/12
+ */
+class PM2VideoFragment :
+    MvpFragment<PM2VideoFragment?, PM2VideoPresenter?>() {
+
+    private var arrayListOf = mutableListOf<RotationItem>()
+
+    override fun getLayoutId(): Int {
+        return R.layout.shuttle_p_m2_video_fragment
+    }
+
+
+    override fun createPresenter(): PM2VideoPresenter {
+        return PM2VideoPresenter(this)
+    }
+
+    companion object {
+        private val TAG = PM2VideoFragment::class.java.simpleName
+    }
+
+    override fun getTagName(): String {
+        return TAG
+    }
+
+    override fun initViews() {
+        initResourceData()
+        imageVideoRotationView.setData(arrayListOf)
+    }
+
+    override fun onPause() {
+        super.onPause()
+        imageVideoRotationView.setPause()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        imageVideoRotationView.setResume()
+    }
+
+    private fun initResourceData() {
+
+        try {
+            arrayListOf.clear()
+            var datas: AdsDatas = GsonUtils.fromJson(FunctionBuildConfig.tempConfig,object : TypeToken<AdsDatas>() {}.type)
+            arrayListOf.addAll(datas.ads)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/M2BlueToothView.kt

@@ -0,0 +1,36 @@
+package com.mogo.och.shuttle.passenger.ui.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import com.mogo.eagle.core.function.api.devatools.IMoGoDevaToolsListener
+import com.mogo.eagle.core.function.hmi.ui.widget.BlueToothView
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.android.synthetic.main.shuttle_p_m2_view_blue_tooth.view.blueView
+
+/**
+ * 魔戒蓝牙控件
+ * 放置于StatusBar右侧位置
+ */
+class M2BlueToothView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : BlueToothView(context, attrs, defStyleAttr),IMoGoDevaToolsListener {
+
+    init {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_m2_view_blue_tooth, this, true)
+    }
+
+    override fun mofangStatus(status: Boolean) {
+        ThreadUtils.runOnUiThread {
+            if (status) {
+                blueView.setImageResource(R.drawable.shuttle_p_m2_blue_tooth_close)
+            } else {
+                blueView.setImageResource(R.drawable.shuttle_p_m2_blue_tooth_open)
+            }
+        }
+    }
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/M2PTrafficLightView.kt

@@ -0,0 +1,181 @@
+package com.mogo.och.shuttle.passenger.ui.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.widget.LinearLayout
+import com.mogo.eagle.core.data.enums.DataSourceType
+import com.mogo.eagle.core.data.enums.TrafficLightEnum
+import com.mogo.eagle.core.function.api.datacenter.union.IMoGoTrafficLightListener
+import com.mogo.eagle.core.function.call.v2x.CallerTrafficLightListenerManager
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.android.synthetic.main.shuttle_p_m2_traffic_light_view.view.m2_p_traffic_light_bg
+import kotlinx.android.synthetic.main.shuttle_p_m2_traffic_light_view.view.m2_p_traffic_light_iv
+import kotlinx.android.synthetic.main.shuttle_p_m2_traffic_light_view.view.m2_p_traffic_light_time_tv
+
+/**
+ * bus乘客端：红绿灯view
+ *
+ * Created on 2022/3/14
+ */
+class M2PTrafficLightView @JvmOverloads constructor(
+    context: Context?,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : LinearLayout(context, attrs, defStyleAttr), IMoGoTrafficLightListener {
+
+    companion object {
+        private const val TAG = "M2PTrafficLightView"
+    }
+
+    private var mCurrentLightId = TrafficLightEnum.BLACK
+
+    init {
+        init(context)
+    }
+
+    private fun init(context: Context?) {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_m2_traffic_light_view, this, true)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        CallerTrafficLightListenerManager.addListener(TAG, this)
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerTrafficLightListenerManager.removeListener(TAG)
+    }
+
+    /**
+     * 展示红绿灯预警
+     *
+     * @param checkLightId 0-都是默认，1-红，2-黄，3-绿
+     * @param lightSource 1:云端下发；2:自车感知
+     */
+    override fun showTrafficLight(checkLightId: TrafficLightEnum, lightSource: DataSourceType) {
+        super.showTrafficLight(checkLightId, lightSource)
+        mCurrentLightId = checkLightId
+        updateTrafficLightIcon(checkLightId)
+    }
+
+    /**
+     * 关闭红绿灯预警展示，并重制灯态
+     */
+    override fun disableTrafficLight() {
+        super.disableTrafficLight()
+        UiThreadHandler.post {
+            mCurrentLightId = TrafficLightEnum.BLACK
+            this@M2PTrafficLightView.visibility = GONE
+        }
+    }
+
+    /**
+     * @param redNum 红灯倒计时
+     * @param yellowNum 黄灯倒计时
+     * @param greenNum 绿灯倒计时
+     */
+    override fun changeCountdownTrafficLightNum(redNum: Int, yellowNum: Int, greenNum: Int) {
+        super.changeCountdownTrafficLightNum(redNum, yellowNum, greenNum)
+        resetView()
+        when (mCurrentLightId) {
+            TrafficLightEnum.RED -> changeCountdownRed(redNum)
+            TrafficLightEnum.YELLOW -> changeCountdownYellow(yellowNum)
+            TrafficLightEnum.GREEN -> changeCountdownGreen(greenNum)
+            else -> UiThreadHandler.post { m2_p_traffic_light_time_tv.text = "" }
+        }
+    }
+
+    override fun changeCountdownRed(redNum: Int) {
+        super.changeCountdownRed(redNum)
+        UiThreadHandler.post {
+            if (redNum > 0) {
+                resetView()
+                m2_p_traffic_light_time_tv.text = redNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                m2_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    override fun changeCountdownGreen(greenNum: Int) {
+        super.changeCountdownGreen(greenNum)
+        UiThreadHandler.post {
+            if (greenNum > 0) {
+                resetView()
+                m2_p_traffic_light_time_tv.text = greenNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                m2_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    override fun changeCountdownYellow(yellowNum: Int) {
+        super.changeCountdownYellow(yellowNum)
+        UiThreadHandler.post {
+            if (yellowNum > 0) {
+                resetView()
+                m2_p_traffic_light_time_tv.text = yellowNum.toString()
+            } else {
+                disableTrafficLightCountDown()
+                m2_p_traffic_light_time_tv.text = ""
+            }
+        }
+    }
+
+    /**
+     * 更新红绿灯icon
+     *
+     * @param lightId 0-都是默认，1-红，2-黄，3-绿
+     */
+    private fun updateTrafficLightIcon(lightId: TrafficLightEnum) {
+        UiThreadHandler.post {
+            when (lightId) {
+                TrafficLightEnum.RED -> {
+                    m2_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_m2_light_red_nor)
+                    this@M2PTrafficLightView.visibility = VISIBLE
+                }
+                TrafficLightEnum.YELLOW -> {
+                    m2_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_m2_light_yellow_nor)
+                    this@M2PTrafficLightView.visibility = VISIBLE
+                }
+                TrafficLightEnum.GREEN -> {
+                    m2_p_traffic_light_iv.setBackgroundResource(R.drawable.shuttle_p_m2_light_green_nor)
+                    this@M2PTrafficLightView.visibility = VISIBLE
+                }
+                else -> this@M2PTrafficLightView.visibility = GONE
+            }
+        }
+    }
+
+    override fun disableTrafficLightCountDown() {
+        super.disableTrafficLightCountDown()
+        UiThreadHandler.post {
+            val layoutParams = layoutParams
+            if (layoutParams is MarginLayoutParams) {
+                val lp = layoutParams
+                lp.width = resources.getDimension(R.dimen.dp_40).toInt()
+                setLayoutParams(lp)
+                m2_p_traffic_light_time_tv.visibility = GONE
+                m2_p_traffic_light_bg.layoutParams.width =
+                    resources.getDimension(R.dimen.dp_40).toInt()
+            }
+        }
+    }
+
+    private fun resetView() {
+        val layoutParams = layoutParams
+        if (layoutParams is MarginLayoutParams) {
+            val lp = layoutParams
+            lp.width = resources.getDimension(R.dimen.dp_60).toInt()
+            setLayoutParams(lp)
+            m2_p_traffic_light_time_tv.visibility = VISIBLE
+            m2_p_traffic_light_bg.layoutParams.width =
+                resources.getDimension(R.dimen.dp_60).toInt()
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/M2StatusBarView.kt

@@ -0,0 +1,110 @@
+package com.mogo.och.shuttle.passenger.ui.widget
+
+import android.annotation.*
+import android.content.Context
+import android.graphics.Color
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.ViewGroup
+import androidx.constraintlayout.widget.ConstraintLayout
+import chassis.ChassisStatesOuterClass
+import com.mogo.eagle.core.function.api.autopilot.IMoGoBatteryManagementSystemListener
+import com.mogo.eagle.core.function.api.hmi.view.IViewControlListener
+import com.mogo.eagle.core.function.api.setting.IMoGoSkinModeChangeListener
+import com.mogo.eagle.core.function.call.autopilot.CallerBatteryManagementSystemListenerManager
+import com.mogo.eagle.core.function.call.devatools.CallerDevaToolsManager
+import com.mogo.eagle.core.function.call.hmi.CallerHmiViewControlListenerManager
+import com.mogo.eagle.core.function.call.setting.CallerSkinModeListenerManager
+import com.mogo.eagle.core.utilcode.kotlin.*
+import com.mogo.eagle.core.utilcode.util.ClickUtils
+import com.mogo.och.shuttle.passenger.R
+import kotlinx.android.synthetic.main.shuttle_p_m2_view_status_bar.view.progress
+import kotlinx.android.synthetic.main.shuttle_p_m2_view_status_bar.view.tv_power_cos
+import kotlinx.coroutines.*
+import me.jessyan.autosize.utils.AutoSizeUtils
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/14
+ */
+class M2StatusBarView @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : ConstraintLayout(context, attrs), IViewControlListener, IMoGoSkinModeChangeListener,
+    IMoGoBatteryManagementSystemListener {
+
+    companion object {
+        const val TAG = "M2StatusBarView"
+    }
+
+    @Volatile
+    private var oldBmsSoc: Float = -1.0f
+
+    init {
+        LayoutInflater.from(context).inflate(R.layout.shuttle_p_m2_view_status_bar, this, true)
+        setBackgroundColor(Color.parseColor("#80FFFFFF"))
+        isClickable = true
+        isFocusable = true
+    }
+
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        post {
+            val params: ViewGroup.LayoutParams = getLayoutParams()
+            params.height = AutoSizeUtils.dp2px(context,40f)
+            layoutParams = params
+        }
+        //添加view控制
+        CallerHmiViewControlListenerManager.addListener(TAG,this)
+        // 添加换肤监听
+        CallerSkinModeListenerManager.addListener(TAG, this)
+        //电量
+        CallerBatteryManagementSystemListenerManager.addListener(TAG,this)
+
+        progress?.also {
+            it.progress = 50
+        }
+        tv_power_cos?.also {
+            it.text = "50%"
+        }
+    }
+
+    override fun onSkinModeChange(skinMode: Int) {
+        when (skinMode) {
+            0 -> setStatusBarDarkOrLight(false)
+            1 -> setStatusBarDarkOrLight(true)
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerHmiViewControlListenerManager.removeListener(TAG)
+        CallerSkinModeListenerManager.removeListener(TAG)
+        CallerDevaToolsManager.hideStatusBar()
+    }
+
+    @SuppressLint("SetTextI18n")
+    override fun onBatteryManagementSystemStates(states: ChassisStatesOuterClass.BMSSystemStates) {
+        if (ClickUtils.isClickTooFrequent(this,1000)) {
+            return
+        }
+        val bmsSoc = states.bmsSoc
+        try {
+            if (oldBmsSoc != bmsSoc ) {
+                scope.launch {
+                    if(bmsSoc >1){
+                        progress?.also { it.progress = bmsSoc.toInt() }
+                        tv_power_cos?.also { it.text = "${bmsSoc.toInt()}%" }
+                    }else{
+                        val power = (bmsSoc * 100).toInt()
+                        progress?.also { it.progress = power }
+                        tv_power_cos?.also {it.text = "$power%" }
+                    }
+                }
+            }
+        } finally {
+            oldBmsSoc = bmsSoc
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/M2TurnLightView.kt

@@ -0,0 +1,199 @@
+package com.mogo.och.shuttle.passenger.ui.widget
+
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.content.Context
+import android.util.AttributeSet
+import android.view.LayoutInflater
+import android.view.View
+import android.view.animation.AlphaAnimation
+import android.view.animation.Animation
+import android.widget.ImageView
+import androidx.constraintlayout.widget.ConstraintLayout
+import com.mogo.eagle.core.function.api.datacenter.union.IMoGoTurnLightListener
+import com.mogo.eagle.core.function.call.autopilot.CallerChassisLamplightListenerManager
+import com.mogo.eagle.core.function.call.v2x.CallerTurnLightListenerManager
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.och.shuttle.passenger.R
+import com.mogo.och.common.module.manager.lightmanager.TurnLightManager
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.left_nor_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.left_select_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.right_nor_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.right_select_image
+import kotlinx.android.synthetic.main.shuttle_p_jl_turn_light_status.view.turn_light_layout
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/13
+ */
+class M2TurnLightView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : ConstraintLayout(context, attrs, defStyleAttr),
+    IMoGoTurnLightListener, TurnLightManager.TurnLightListener {
+
+
+    companion object {
+        private const val TAG = "TurnLightViewStatus"
+    }
+
+    private var isLeftLight: Boolean = false
+    private var isRightLight: Boolean = false
+    private var isDisappear: Boolean = false
+
+    init {
+        LayoutInflater.from(context)
+            .inflate(R.layout.shuttle_p_m2_turn_light_status, this, true)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        CallerTurnLightListenerManager.addListener(TAG,this)
+
+        TurnLightManager.addTurnLightStatusChangeListener(TAG,this)
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        CallerChassisLamplightListenerManager.removeListener(TAG)
+        CallerTurnLightListenerManager.removeListener(TAG)
+    }
+
+    override fun hideTurnLightView() {
+        ThreadUtils.runOnUiThread{
+            if (!isDisappear) {
+                isDisappear = true
+                isLeftLight = false
+                isRightLight = false
+                animationDisappear()
+            }
+        }
+    }
+
+    override fun statusChange(newStatus: TurnLightManager.TurnLightStatus) {
+        ThreadUtils.runOnUiThread {
+            setTurnLight(newStatus)
+        }
+    }
+
+    /**
+     * 转向灯动画
+     */
+    private fun setTurnLight(directionLight: TurnLightManager.TurnLightStatus) {
+        if (!isAttachedToWindow) {
+            return
+        }
+        //根据左右进行显示和隐藏，实际要判断每个来的时间和频度
+        when (directionLight) {
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_LEFT -> { //左转向
+                if (!isLeftLight) {
+                    isLeftLight = true
+                    isRightLight = false
+                    isDisappear = false
+                    showNormalAnimation()
+                    left_select_image.visibility = View.VISIBLE
+                    right_select_image.visibility = View.GONE
+                    right_select_image.clearAnimation()
+                    setAnimation(left_select_image)
+                }
+            }
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_RIGHT -> { //右转向
+                if (!isRightLight) {
+                    isRightLight = true
+                    isLeftLight = false
+                    isDisappear = false
+                    showNormalAnimation()
+                    left_select_image.visibility = View.GONE
+                    right_select_image.visibility = View.VISIBLE
+                    left_select_image.clearAnimation()
+                    setAnimation(right_select_image)
+                }
+            }
+            TurnLightManager.TurnLightStatus.TURN_LIGHT_NONE -> { //消失
+                if (!isDisappear) {
+                    isDisappear = true
+                    isLeftLight = false
+                    isRightLight = false
+                    animationDisappear()
+                }
+            }
+        }
+    }
+
+    //显示背景
+    private fun showNormalAnimation() {
+        val appearAnimation = AlphaAnimation(0f, 1.0f)
+        appearAnimation.duration = 300
+        val appearAnimationImage = AlphaAnimation(0f, 1.0f)
+        appearAnimation.duration = 500
+        turn_light_layout.startAnimation(appearAnimation)
+        left_nor_image.startAnimation(appearAnimationImage)
+        right_nor_image.startAnimation(appearAnimationImage)
+
+        turn_light_layout.visibility = View.VISIBLE
+        left_nor_image.visibility = View.VISIBLE
+        right_nor_image.visibility = View.VISIBLE
+    }
+
+    //消失动画，当转向等数据为空时候
+    private fun animationDisappear() {
+        left_select_image.visibility = View.GONE
+        right_select_image.visibility = View.GONE
+        left_select_image.clearAnimation()
+        right_select_image.clearAnimation()
+
+        left_nor_image.clearAnimation()
+        right_nor_image.clearAnimation()
+        turn_light_layout.clearAnimation()
+
+        val disappearAnimationLeft = AlphaAnimation(1.0f, 0f)
+        disappearAnimationLeft.duration = 300
+
+        val disappearAnimationBg = AlphaAnimation(1.0f, 0f)
+        disappearAnimationBg.duration = 500
+
+        left_nor_image.startAnimation(disappearAnimationLeft)
+        right_nor_image.startAnimation(disappearAnimationLeft)
+        turn_light_layout.startAnimation(disappearAnimationBg)
+
+        disappearAnimationLeft.setAnimationListener(object : Animation.AnimationListener {
+            override fun onAnimationRepeat(p0: Animation?) {
+            }
+
+            override fun onAnimationStart(p0: Animation?) {
+            }
+
+            override fun onAnimationEnd(p0: Animation?) {
+                left_nor_image.visibility = View.GONE
+                right_nor_image.visibility = View.GONE
+            }
+        })
+
+        disappearAnimationBg.setAnimationListener(object : Animation.AnimationListener {
+            override fun onAnimationRepeat(p0: Animation?) {
+            }
+
+            override fun onAnimationStart(p0: Animation?) {
+            }
+
+            override fun onAnimationEnd(p0: Animation?) {
+                turn_light_layout.visibility = View.GONE
+            }
+        })
+    }
+
+    //实现图片闪烁效果
+    private fun setAnimation(imageView: ImageView) {
+        val animationSet = AnimatorSet()
+        val valueAnimator = ObjectAnimator.ofFloat(imageView, "alpha", 0f, 1.0f)
+        val valueAnimatorDisappear = ObjectAnimator.ofFloat(imageView, "alpha", 1.0f, 0f)
+        valueAnimator.duration = 1000
+        valueAnimatorDisappear.duration = 800
+        valueAnimator.repeatCount = -1
+        valueAnimatorDisappear.repeatCount = -1
+        animationSet.playTogether(valueAnimatorDisappear, valueAnimator)
+        animationSet.start()
+    }
+
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/AdvanceGSYVideoPlayer.kt

@@ -0,0 +1,137 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.content.Context
+import android.media.AudioManager
+import android.util.AttributeSet
+import com.mogo.eagle.core.utilcode.mogo.logger.Logger
+import com.mogo.eagle.core.widget.media.video.TextureVideoViewOutlineProvider
+import com.shuyu.gsyvideoplayer.utils.GSYVideoType
+import com.shuyu.gsyvideoplayer.video.StandardGSYVideoPlayer
+import me.jessyan.autosize.utils.AutoSizeUtils
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/17
+ * 隐藏所有控件的player
+ */
+class AdvanceGSYVideoPlayer: StandardGSYVideoPlayer {
+    constructor(context: Context?) : super(context)
+    constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
+
+    init {
+        hideWidget()
+        GSYVideoType.setShowType(GSYVideoType.SCREEN_TYPE_16_9)
+        GSYVideoType.setRenderType(GSYVideoType.GLSURFACE)
+    }
+
+    override fun hideAllWidget() {
+        Logger.d(ImageAndVideoRotation.TAG, "hideAllWidget")
+//        hideWidget()
+    }
+
+    override fun changeUiToNormal() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToNormal-hide")
+        hideWidget()
+    }
+
+    override fun changeUiToPreparingShow() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToPreparingShow-hide")
+        hideWidget()
+    }
+
+    override fun changeUiToPlayingShow() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToPlayingShow")
+        setCacheImageViewGone()
+    }
+
+    override fun changeUiToPauseShow() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToPauseShow-hide")
+        startPlayLogic()
+//        hideWidget()
+    }
+
+    override fun changeUiToCompleteShow() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToCompleteShow")
+        setCacheImageViewGone()
+    }
+
+    override fun changeUiToPlayingBufferingShow() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToPlayingBufferingShow -hide")
+       hideWidget()
+    }
+
+    override fun changeUiToError() {
+        Logger.d(ImageAndVideoRotation.TAG, "changeUiToError-hide")
+        hideWidget()
+    }
+
+    private fun hideWidget(){
+        setViewShowState(mBottomContainer, INVISIBLE)
+        setViewShowState(mProgressBar, INVISIBLE)
+        setViewShowState(mCurrentTimeTextView, INVISIBLE)
+        setViewShowState(mTotalTimeTextView, INVISIBLE)
+        setViewShowState(mBottomProgressBar, INVISIBLE)
+        setViewShowState(mBackButton, INVISIBLE)
+        setViewShowState(mStartButton, INVISIBLE)
+
+        setViewShowState(mThumbImageViewLayout, VISIBLE)
+        setViewShowState(mThumbImageView, VISIBLE)
+
+        setViewShowState(mTopContainer, INVISIBLE)
+
+        setViewShowState(mLoadingProgressBar, INVISIBLE)
+        setViewShowState(
+            mLockScreen, INVISIBLE
+        )
+
+        setIsTouchWiget(false)
+        isFocusableInTouchMode = false
+    }
+
+    fun setCacheImageViewVisible() {
+        Logger.d(ImageAndVideoRotation.TAG, "CacheImageViewVISIBLE")
+        setViewShowState(mThumbImageViewLayout, VISIBLE)
+//        setViewShowState(mThumbImageView, VISIBLE)
+    }
+
+    fun setCacheImageViewGone() {
+        Logger.d(ImageAndVideoRotation.TAG, "CacheImageViewGONE")
+        setViewShowState(mThumbImageViewLayout, INVISIBLE)
+//        setViewShowState(mThumbImageView, INVISIBLE)
+    }
+
+    //失去焦点声音压低
+    override fun onLossTransientCanDuck() {
+//        setStreamVolume(0.2f)
+        setNeedMute(true)
+    }
+
+    //获取焦点声音恢复
+    override fun onGankAudio() {
+//        setStreamVolume(5.0f)
+        setNeedMute(false)
+    }
+
+    private fun setStreamVolume(percent: Float){
+        var mAudioManager = mContext?.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        var maxVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
+        var volume = (percent * maxVolume).toInt()
+        if (volume < 0 ){
+            volume = 0
+        }
+        mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,volume,0)
+    }
+
+    private fun setNeedMute(isMute: Boolean){
+        gsyVideoManager?.player?.setNeedMute(isMute)
+    }
+
+    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+        super.onSizeChanged(w, h, oldw, oldh)
+        if (!mIfCurrentIsFullscreen) {
+            val dp2px = AutoSizeUtils.dp2px(context, 16f)
+            this.outlineProvider = TextureVideoViewOutlineProvider(dp2px.toFloat())
+            this.clipToOutline = true
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/AdvanceImageView.kt

@@ -0,0 +1,45 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.util.AttributeSet
+import android.widget.ImageView
+import android.widget.RelativeLayout
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.RequestOptions
+import com.mogo.och.shuttle.passenger.R
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/6
+ */
+class AdvanceImageView @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : RelativeLayout(context, attrs) {
+
+    private var imageView: ImageView? = null
+
+    init {
+        initView()
+    }
+
+    private fun initView() {
+        imageView = ImageView(context)
+        imageView?.scaleType = ImageView.ScaleType.FIT_XY
+        addView(imageView, LayoutParams(-1, -1))
+    }
+
+    @SuppressLint("CheckResult")
+    fun setImagePath(path: String){
+        imageView?.setImageResource(R.drawable.shuttle_p_m2_p_video_holder)
+        imageView?.let { Glide.with(context).asBitmap().load(path)
+            .apply(
+                RequestOptions().useUnlimitedSourceGeneratorsPool(true)
+                    .placeholder(R.drawable.shuttle_p_m2_p_video_holder)
+                    .error(R.drawable.shuttle_p_m2_p_video_holder)
+                    .fallback(R.drawable.shuttle_p_m2_p_video_holder)
+                    .centerCrop()
+            )
+            .into(it) }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/AdvancePagerAdapter.kt

@@ -0,0 +1,211 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import androidx.viewpager.widget.PagerAdapter
+import androidx.viewpager.widget.ViewPager
+import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
+import com.mogo.eagle.core.utilcode.mogo.logger.Logger
+import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.eagle.core.utilcode.util.CountDownTimer
+import com.mogo.och.common.module.wigets.video.RotationItem
+import com.shuyu.gsyvideoplayer.listener.GSYSampleCallBack
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/6
+ */
+class AdvancePagerAdapter(context: Context, viewPager: ViewPager) : PagerAdapter(),
+    ViewPager.OnPageChangeListener {
+
+    private val mContext: Context = context
+    private val mViewPager: ViewPager = viewPager
+
+    private var dataList = mutableListOf<RotationItem>()
+    private var viewList = mutableListOf<View>()
+
+    private var lastPosition = -1
+
+    private var current = 0
+    private val time = 5000
+    private var pause = false
+    private var countDownTimer: CountDownTimer? = null
+
+    fun setData(list: MutableList<RotationItem>) {
+        if (list.isEmpty()) return
+        dataList.addAll(list)
+
+        viewList.clear()
+
+        list.forEach {
+            addView(it)
+        }
+
+        mViewPager.addOnPageChangeListener(this)
+
+        notifyDataSetChanged()
+
+        mViewPager.currentItem = 0
+
+        if (viewList.size > 0) {
+            if (viewList[mViewPager.currentItem] is AdvanceVideoView) {//有人反应第一个是视频不播放这边优化了一下
+                Logger.d(ImageAndVideoRotation.TAG, "第一个是视频")
+                val video = viewList[mViewPager.currentItem] as AdvanceVideoView
+                video.setVideo(gsySampleCallBack)
+
+            } else if (viewList[mViewPager.currentItem] is AdvanceImageView) {
+                Logger.d(ImageAndVideoRotation.TAG, "startTimer()_1")
+                current = 0//换页重新计算时间
+                startTimer()
+            }
+        }
+    }
+
+    override fun getCount(): Int {
+        return dataList.size
+    }
+
+    override fun isViewFromObject(view: View, `object`: Any): Boolean {
+        return view === `object`
+    }
+
+    override fun destroyItem(container: ViewGroup, position: Int, `object`: Any) {
+        container.removeView(viewList[position])
+    }
+
+    override fun instantiateItem(container: ViewGroup, position: Int): Any {
+        val view: View = viewList[position]
+        container.addView(view)
+        return view
+
+    }
+
+    override fun getItemPosition(`object`: Any): Int {
+        return POSITION_NONE
+    }
+
+    private fun addView(item: RotationItem) {
+        if (item.type == 1) { // 表示视频
+            val videoView = AdvanceVideoView(mContext)
+            videoView.setVideoPath(item.path,item.cacheImgPath)
+            viewList.add(videoView)
+        } else {  // 表示图片
+            val imageView = AdvanceImageView(mContext)
+            imageView.setImagePath(item.path)
+            viewList.add(imageView)
+        }
+    }
+
+    fun setPause() {
+        pause = true
+        if (viewList.size > 0 && viewList[mViewPager.currentItem] is AdvanceVideoView) {
+            val videoView = viewList[mViewPager.currentItem] as AdvanceVideoView
+            videoView.setPause()
+        }
+    }
+
+    fun setResume() {
+        pause = false
+        if (viewList.size > 0 && viewList[mViewPager.currentItem] is AdvanceVideoView) {
+            val videoView = viewList[mViewPager.currentItem] as AdvanceVideoView
+            videoView.setResume()
+        }
+    }
+
+    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+    }
+
+    override fun onPageSelected(position: Int) {
+    }
+
+    override fun onPageScrollStateChanged(state: Int) {
+        // 由于viewpager的预加载机制onPageSelected这里面加载videoview 放的跟玩一样  等操作完成后再播放videoview就香了  很丝滑
+        if (state == 0) { //静止，什么都没做
+            val currentItem = mViewPager.currentItem
+            Logger.d(ImageAndVideoRotation.TAG,
+                "state = $state currentItem = $currentItem lastPosition = $lastPosition")
+
+            if (viewList.size > 1) { //多于1，才会循环跳转
+
+                if (viewList[mViewPager.currentItem] is AdvanceVideoView) {
+
+                    val videoView = (viewList[mViewPager.currentItem] as AdvanceVideoView)
+                    videoView.setCacheImageViewVisible()
+                    videoView.setVideo(gsySampleCallBack)
+
+                } else if (viewList[mViewPager.currentItem] is AdvanceImageView) {
+                    Logger.d(ImageAndVideoRotation.TAG, "startTimer()")
+                    current = 0//换页重新计算时间
+                    startTimer()
+                }
+                lastPosition = mViewPager.currentItem
+            }
+        }
+    }
+
+    private var gsySampleCallBack = object : GSYSampleCallBack() {
+
+        override fun onPrepared(url: String?, vararg objects: Any?) {
+            Logger.d(ImageAndVideoRotation.TAG, "onPrepared--$url")
+        }
+
+        override fun onAutoComplete(url: String?, vararg objects: Any?) {
+            Logger.d(ImageAndVideoRotation.TAG, "onAutoComplete()-$url")
+            if (viewList[mViewPager.currentItem] is AdvanceVideoView){
+                val videoView = (viewList[mViewPager.currentItem] as AdvanceVideoView)
+                if (viewList.size == 1){
+                    videoView.startPlay(url)
+                }else{
+                    videoView.onVideoReset()
+                    goNextItemView()
+                }
+            }
+        }
+
+        override fun onPlayError(url: String?, vararg objects: Any?) {
+            super.onPlayError(url, *objects)
+            Logger.d(ImageAndVideoRotation.TAG, "onPlayError()-$url")
+            if (viewList[mViewPager.currentItem] is AdvanceVideoView){
+                val videoView = (viewList[mViewPager.currentItem] as AdvanceVideoView)
+                videoView.onVideoReset()
+//                videoView.setCacheImageViewVisible()
+                videoView.clearLocalErrorVideo()
+                goNextItemView()
+            }
+        }
+    }
+
+    private fun startTimer() {
+        if (countDownTimer != null){
+            countDownTimer?.cancel()
+            countDownTimer = null
+        }
+        countDownTimer = object : CountDownTimer(5000,1000){
+            override fun onTick(millisUntilFinished: Long) {
+                d(SceneConstant.M_BUS_P + "startTimer", "倒计时秒 = ${millisUntilFinished/1000}" )
+            }
+
+            override fun onFinish() {
+                d(ImageAndVideoRotation.TAG+ "startTimer", "5s到，跳转")
+                goNextItemView()
+            }
+
+        }.start()
+    }
+
+    /**
+     * view 跳转
+     */
+    private fun goNextItemView() {
+        if (mViewPager.currentItem == viewList.size - 1) {//已经到最后一个
+            mViewPager.post {
+                mViewPager.setCurrentItem(0, true)
+            }
+        } else {
+            mViewPager.post {
+                mViewPager.setCurrentItem(mViewPager.currentItem + 1, true)
+            }
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/AdvanceVideoView.kt

@@ -0,0 +1,254 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.Uri
+import android.util.AttributeSet
+import android.widget.ImageView
+import android.widget.RelativeLayout
+import com.mogo.eagle.core.utilcode.download.*
+import com.mogo.eagle.core.utilcode.download.callback.*
+import com.mogo.eagle.core.utilcode.mogo.logger.Logger
+import com.mogo.eagle.core.utilcode.util.FileUtils
+import com.mogo.eagle.core.utilcode.util.ThreadUtils
+import com.mogo.eagle.core.utilcode.util.UiThreadHandler
+import com.mogo.och.shuttle.passenger.R
+import com.shuyu.gsyvideoplayer.builder.GSYVideoOptionBuilder
+import com.shuyu.gsyvideoplayer.listener.GSYSampleCallBack
+import java.io.File
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/8
+ */
+class AdvanceVideoView @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : RelativeLayout(context, attrs) {
+
+    private var videoRelativeLayout: RelativeLayout? = null
+    private var cacheImage: ImageView? = null
+
+    private var videoViewPlayer: AdvanceGSYVideoPlayer? = null
+    private var gsyVideoOptionBuilder: GSYVideoOptionBuilder? = null
+    private var mOnCompletionListener: GSYSampleCallBack? = null
+    private var downloadVideoName = ""
+    private var fileNetPath: String? = ""
+    private var cacheImageUrl: String? = ""
+    private var mVideoDirPath: String? = ""
+
+    init {
+        mVideoDirPath = context.filesDir.absolutePath + File.separator + "video" + File.separator
+//        mVideoDirPath = Config.downLoadPath
+        initView()
+    }
+
+    private fun initView() {
+        initVideoView()
+        initCacheImgView()
+    }
+
+    private fun initCacheImgView() {
+        cacheImage = ImageView(context)
+        cacheImage?.scaleType = ImageView.ScaleType.FIT_XY
+//        addView(cacheImage, LayoutParams(-1, -1))
+    }
+
+    private fun initVideoView() {
+        videoRelativeLayout = RelativeLayout(context)
+        val outLayout = LayoutParams(-1, -1)
+        addView(videoRelativeLayout, outLayout)
+
+        if (videoViewPlayer === null) {
+            //视频播放控件
+            videoViewPlayer = AdvanceGSYVideoPlayer(context)
+        }
+
+        val layoutParams = LayoutParams(-1, -1)
+        //设置videoview占满父view播放
+        layoutParams.addRule(ALIGN_PARENT_LEFT)
+        layoutParams.addRule(ALIGN_PARENT_RIGHT)
+        layoutParams.addRule(ALIGN_PARENT_TOP)
+        layoutParams.addRule(ALIGN_PARENT_BOTTOM)
+
+        videoRelativeLayout?.addView(videoViewPlayer, layoutParams)
+    }
+
+    fun setVideoPath(path: String, cacheImageUrl: String) {
+        // https://img.zhidaohulian.com/fileServer/online_car_hailing/1676357834634/5.m4v
+        // https://img.zhidaohulian.com/fileServer/online_car_hailing/1676360274126/10.mp4
+        this.fileNetPath = path
+        this.cacheImageUrl = cacheImageUrl
+        val pathList = path.split("/")
+        if (pathList.isNotEmpty()) {
+            this.downloadVideoName = pathList[pathList.size - 1]
+        }
+    }
+
+    private fun loadCacheImg() {
+        //        BitmapHelper.getVideoThumbnail(path) /*获取第一帧图*
+//        OCHThreadPoolManager.getsInstance().execute {
+//            var bitmap = BitmapHelper.getVideoThumbnail(fileNetPath)
+        Logger.d(ImageAndVideoRotation.TAG, "setVideoPath")
+//            ThreadUtils.runOnUiThread {
+//                Logger.d(ImageAndVideoRotation.TAG, "bitmap加载")
+        cacheImage?.setImageResource(R.drawable.shuttle_p_m2_p_video_holder)
+//        cacheImage?.let { //暂时去掉加载首帧图，加载视频时，用本地默认图
+//                    Glide.with(context).asBitmap().load(cacheImageUrl)
+//                        .apply(
+//                            RequestOptions().useUnlimitedSourceGeneratorsPool(true)
+//                                .placeholder(R.drawable.m2_p_video_holder)
+//                                .error(R.drawable.m2_p_video_holder)
+//                                .fallback(R.drawable.m2_p_video_holder)
+//                                .centerCrop()
+//                        )
+//                        .into(it)
+//                }
+        videoViewPlayer?.thumbImageView = cacheImage
+//        setCacheImageViewVisible()
+//            }
+//        }
+    }
+
+    fun clearLocalErrorVideo() {
+        if (downloadVideoName.isNotEmpty()
+            && FileUtils.isFileExists(mVideoDirPath + downloadVideoName)
+        ) {
+            FileUtils.delete(mVideoDirPath + downloadVideoName)
+        }
+    }
+
+    @SuppressLint("CheckResult")
+    fun setCacheImageViewVisible() {
+        UiThreadHandler.post {
+//            cacheImage?.visibility = VISIBLE
+            videoViewPlayer?.setCacheImageViewVisible()
+        }
+    }
+
+    fun setCacheImageViewGone() {
+        UiThreadHandler.post {
+//            cacheImage?.visibility = GONE
+            videoViewPlayer?.setCacheImageViewGone()
+        }
+
+    }
+
+    fun setVideo(onCompletionListener: GSYSampleCallBack) {
+        loadCacheImg()
+        Logger.d(ImageAndVideoRotation.TAG, "setVideo")
+        mOnCompletionListener = onCompletionListener
+        //判断是否已经下载
+        if (downloadVideoName.isNotEmpty()) {
+            Logger.d(
+                ImageAndVideoRotation.TAG,
+                "video local url = $mVideoDirPath$downloadVideoName"
+            )
+            if (FileUtils.isFileExists(mVideoDirPath + downloadVideoName)) {
+                Logger.d(ImageAndVideoRotation.TAG, "have cache startPlay")
+                startPlay(Uri.fromFile(File(mVideoDirPath + downloadVideoName)).toString())
+                return
+            }
+            startDownLoadVideo()
+        }
+    }
+
+    private fun startDownLoadVideo() {
+        //下载视频， 下载成功后再播放
+        Logger.d(ImageAndVideoRotation.TAG, "startDownLoadVideo")
+        FileUtils.createFileDir(mVideoDirPath)
+        val downloadUrl = fileNetPath
+        val downloadDir = mVideoDirPath
+        if (downloadUrl != null && downloadDir != null) {
+            DownloadUtils.downLoad(
+                context, downloadUrl, downloadDir, downloadVideoName,  downListener
+            )
+        }
+    }
+
+    fun startPlay(localVideoPath: String?) {
+        if (localVideoPath === "") return
+        try {
+            Logger.d(ImageAndVideoRotation.TAG, "startPlay")
+            gsyVideoOptionBuilder = GSYVideoOptionBuilder()
+            gsyVideoOptionBuilder
+//                ?.setUrl("file:///mnt/sdcard/downloads/$downloadVideoName")
+                ?.setUrl(localVideoPath) //  "/data/user/0/com.mogo.launcher.f/files/video/"
+                ?.setPlayTag(downloadVideoName)
+                ?.setCacheWithPlay(false)
+                ?.setThumbPlay(false)
+                ?.build(videoViewPlayer)
+
+            videoViewPlayer?.isFocusableInTouchMode = false
+            videoViewPlayer?.setVideoAllCallBack(mOnCompletionListener)
+            videoViewPlayer?.startPlayLogic()
+        } catch (e: Exception) {
+            Logger.d(ImageAndVideoRotation.TAG, "startPlay e = ${e.message}")
+        }
+    }
+
+    fun onVideoReset() {
+        videoViewPlayer?.onVideoReset()
+        mOnCompletionListener = null
+    }
+
+    fun setPause() {
+        if (videoViewPlayer !== null) {
+            videoViewPlayer?.onVideoPause()
+        }
+    }
+
+    fun setResume() {
+        if (videoViewPlayer !== null) {
+            videoViewPlayer?.onVideoResume()
+        }
+    }
+
+    private val downListener = object : IDownloadListener {
+        override fun onStart(url: String) {
+            setCacheImageViewVisible()
+            Logger.d(ImageAndVideoRotation.TAG, "download-onStart")
+        }
+
+//        override fun onPause(url: String, threadBean: ThreadBean?) {
+//            Logger.d(ImageAndVideoRotation.TAG, "download-onPause")
+////            UiThreadHandler.postDelayed(Runnable {
+////                startDownLoadVideo()
+////            },DOWNLOAD_DELAY)
+//            // todo 测试下网络断掉是否会走onpause，且网络回复也不会继续下载
+//        }
+
+        override fun onProgress(url: String, downloaded: Long, total: Long) {
+            Logger.d(ImageAndVideoRotation.TAG, "download-onProgress== ${ (downloaded * 1.0f * 100/total).toInt() }")
+        }
+
+        override fun onFinished(url: String, path: String) {
+            Logger.d(ImageAndVideoRotation.TAG, "download-onFinished = $url")
+            if (url.equals(fileNetPath)) { //发现下载工具在断网又连网后，已完成的任务又都下载，跳转播放出现问题
+                //下载完成
+                ThreadUtils.runOnUiThread {
+                    startPlay(Uri.fromFile(File(path)).toString())
+                }
+            } else {//如果当前文件不存在再次去下载当前的
+                Logger.d(
+                    ImageAndVideoRotation.TAG, "download-onFinished = not current" +
+                            ",currentUrl = $fileNetPath "
+                )
+                if (FileUtils.isFileExists(path)) {
+                    Logger.d(ImageAndVideoRotation.TAG, "have download startPlay")
+                    ThreadUtils.runOnUiThread {
+                        startPlay(Uri.fromFile(File(path)).toString())
+                    }
+                    return
+                } else {
+                    startDownLoadVideo()
+                }
+            }
+        }
+
+        override fun onError(url: String, error: String?) {
+            Logger.d(ImageAndVideoRotation.TAG, "download-onError-$error")
+            //出错再次下载
+            startDownLoadVideo()
+        }
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/AdvanceViewPager.kt

@@ -0,0 +1,24 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.MotionEvent
+import androidx.viewpager.widget.ViewPager
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/21
+ */
+class AdvanceViewPager: ViewPager{
+
+    constructor(context: Context) : super(context)
+    constructor(context: Context,attrs: AttributeSet?) : super(context,attrs)
+
+    override fun onTouchEvent(ev: MotionEvent?): Boolean {
+        return false
+    }
+
+    override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
+        return false
+    }
+}

OCH/shuttle/passenger/src/main/java/m2/com/mogo/och/shuttle/passenger/ui/widget/video/ImageAndVideoRotation.kt

@@ -0,0 +1,49 @@
+package com.mogo.och.shuttle.passenger.ui.widget.video
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.util.AttributeSet
+import android.widget.RelativeLayout
+import androidx.viewpager.widget.ViewPager
+import com.mogo.och.common.module.wigets.video.RotationItem
+
+/**
+ * @author: wangmingjun
+ * @date: 2023/2/6
+ */
+class ImageAndVideoRotation @JvmOverloads constructor(
+    context: Context, attrs: AttributeSet? = null
+) : RelativeLayout(context, attrs) {
+
+    private var viewPager: AdvanceViewPager? = null
+    private var pagerAdapter: AdvancePagerAdapter? = null
+
+    companion object {
+        const val TAG = "ImageAndVideoRotation"
+    }
+
+    init {
+        initView()
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    private fun initView() {
+        viewPager = AdvanceViewPager(context)
+        pagerAdapter = AdvancePagerAdapter(context, viewPager!!)
+        viewPager?.adapter = pagerAdapter
+
+        addView(viewPager, LayoutParams(-1, -1))
+    }
+
+    fun setData(list: MutableList<RotationItem>){
+        pagerAdapter?.setData(list)
+    }
+
+    fun setPause(){
+        pagerAdapter?.setPause()
+    }
+
+    fun setResume(){
+        pagerAdapter?.setResume()
+    }
+}