Промежуточный этап синхронизации

app/providers/ProtocolProvider/ProtocolProvider.tsx

@@ -12,10 +12,13 @@ export enum ProtocolState {
     HANDSHAKE_EXCHANGE,
     DISCONNECTED,
     RECONNECTING,
-    DEVICE_VERIFICATION_REQUIRED
+    DEVICE_VERIFICATION_REQUIRED,
+    SYNCHRONIZATION
 }
 
-export const ProtocolContext = createContext<[Protocol|null, ProtocolState]>([null, ProtocolState.DISCONNECTED]);
+export type ProtocolContextType = [Protocol|null, ProtocolState, (state: ProtocolState) => void];
+
+export const ProtocolContext = createContext<ProtocolContextType>([null, ProtocolState.DISCONNECTED, () => {}]);
 
 interface ProtocolProviderProps {
     children: React.ReactNode;
@@ -91,7 +94,7 @@ export function ProtocolProvider(props : ProtocolProviderProps) {
     }, [publicKey, privateKey, systemInfo.id]);
 
     return (
-        <ProtocolContext.Provider value={[protocol, connect]}>
+        <ProtocolContext.Provider value={[protocol, connect, setConnect]}>
             {props.children}
         </ProtocolContext.Provider>
     );

app/providers/ProtocolProvider/protocol/packets/packet.sync.ts

@@ -0,0 +1,48 @@
+import Packet from "../packet";
+import Stream from "../stream";
+
+export enum SyncStatus {
+    NOT_NEEDED,
+    BATCH_START,
+    BATCH_END
+}
+
+export class PacketSync extends Packet {
+
+    private status : SyncStatus = SyncStatus.NOT_NEEDED;
+    private timestamp : number = 0;
+
+    public getPacketId(): number {
+        return 25; //0x19
+    }
+
+    public _receive(stream: Stream): void {
+        this.status = stream.readInt8() as SyncStatus;
+        this.timestamp = stream.readInt64();
+    }
+
+    public _send(): Promise<Stream> | Stream {
+        let stream = new Stream();
+        stream.writeInt16(this.getPacketId());
+        stream.writeInt8(this.status);
+        stream.writeInt64(this.timestamp);
+        return stream;
+    }
+
+    public getStatus() : SyncStatus {
+        return this.status;
+    }
+
+    public setStatus(status: SyncStatus) {
+        this.status = status;
+    }
+
+    public getTimestamp() : number {
+        return this.timestamp;
+    }
+
+    public setTimestamp(timestamp: number) {
+        this.timestamp = timestamp;
+    }
+    
+}

app/providers/ProtocolProvider/protocol/protocol.ts

@@ -24,6 +24,7 @@ import { PacketGroupBan } from "./packets/packet.group.ban";
 import { PacketDeviceNew } from "./packets/packet.device.new";
 import { PacketDeviceList } from "./packets/packet.device.list";
 import { PacketDeviceResolve } from "./packets/packet.device.resolve";
+import { PacketSync } from "./packets/packet.sync";
 
 export default class Protocol extends EventEmitter {
     private serverAddress: string;
@@ -123,6 +124,7 @@ export default class Protocol extends EventEmitter {
         this._supportedPackets.set(0x16, new PacketGroupBan());
         this._supportedPackets.set(0x17, new PacketDeviceList());
         this._supportedPackets.set(0x18, new PacketDeviceResolve());
+        this._supportedPackets.set(25, new PacketSync());
     }
 
     private _findWaiters(packetId: number): ((packet: Packet) => void)[] {

app/providers/ProtocolProvider/useProtocolState.ts

@@ -1,12 +1,12 @@
 import { useContext } from "react";
-import { ProtocolContext } from "./ProtocolProvider";
+import { ProtocolContext, ProtocolContextType, ProtocolState } from "./ProtocolProvider";
 
 export const useProtocolState = () => {
-    const [context, connect] = useContext(ProtocolContext);
+    const context : ProtocolContextType = useContext(ProtocolContext);
 
     if(!context){
         throw new Error("useProtocol must be used within a ProtocolProvider");
     }
 
-    return connect;
+    return [context[1], context[2]] as [ProtocolState, (state: ProtocolState) => void];
 };