Merge pull request #4797 from traccar/polling

Implement polling protocol support

13 files changed, 492 insertions, 47 deletions

diff --git a/src/main/java/org/traccar/BasePipelineFactory.java b/src/main/java/org/traccar/BasePipelineFactory.java
index c9f3a2346..89ef76a80 100644
--- a/src/main/java/org/traccar/BasePipelineFactory.java
+++ b/src/main/java/org/traccar/BasePipelineFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 - 2021 Anton Tananaev (anton@traccar.org)
+ * Copyright 2012 - 2022 Anton Tananaev (anton@traccar.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54,12 +54,12 @@ import java.util.Map;
 
 public abstract class BasePipelineFactory extends ChannelInitializer<Channel> {
 
-    private final TrackerServer server;
+    private final TrackerConnector connector;
     private final String protocol;
     private int timeout;
 
-    public BasePipelineFactory(TrackerServer server, String protocol) {
-        this.server = server;
+    public BasePipelineFactory(TrackerConnector connector, String protocol) {
+        this.connector = connector;
         this.protocol = protocol;
         timeout = Context.getConfig().getInteger(Keys.PROTOCOL_TIMEOUT.withPrefix(protocol));
         if (timeout == 0) {
@@ -67,10 +67,12 @@ public abstract class BasePipelineFactory extends ChannelInitializer<Channel> {
         }
     }
 
+    protected abstract void addTransportHandlers(PipelineBuilder pipeline);
+
     protected abstract void addProtocolHandlers(PipelineBuilder pipeline);
 
     @SafeVarargs
-    private final void addHandlers(ChannelPipeline pipeline, Class<? extends ChannelHandler>... handlerClasses) {
+    private void addHandlers(ChannelPipeline pipeline, Class<? extends ChannelHandler>... handlerClasses) {
         for (Class<? extends ChannelHandler> handlerClass : handlerClasses) {
             if (handlerClass != null) {
                 pipeline.addLast(Main.getInjector().getInstance(handlerClass));
@@ -97,10 +99,12 @@ public abstract class BasePipelineFactory extends ChannelInitializer<Channel> {
     protected void initChannel(Channel channel) {
         final ChannelPipeline pipeline = channel.pipeline();
 
-        if (timeout > 0 && !server.isDatagram()) {
+        addTransportHandlers(pipeline::addLast);
+
+        if (timeout > 0 && !connector.isDatagram()) {
             pipeline.addLast(new IdleStateHandler(timeout, 0, 0));
         }
-        pipeline.addLast(new OpenChannelHandler(server));
+        pipeline.addLast(new OpenChannelHandler(connector));
         pipeline.addLast(new NetworkMessageHandler());
         pipeline.addLast(new StandardLoggingHandler(protocol));
 
diff --git a/src/main/java/org/traccar/BaseProtocol.java b/src/main/java/org/traccar/BaseProtocol.java
index bd3391822..52d34dc44 100644
--- a/src/main/java/org/traccar/BaseProtocol.java
+++ b/src/main/java/org/traccar/BaseProtocol.java
@@ -35,7 +35,7 @@ public abstract class BaseProtocol implements Protocol {
     private final String name;
     private final Set<String> supportedDataCommands = new HashSet<>();
     private final Set<String> supportedTextCommands = new HashSet<>();
-    private final List<TrackerServer> serverList = new LinkedList<>();
+    private final List<TrackerConnector> connectorList = new LinkedList<>();
 
     private StringProtocolEncoder textCommandEncoder = null;
 
@@ -54,12 +54,16 @@ public abstract class BaseProtocol implements Protocol {
     }
 
     protected void addServer(TrackerServer server) {
-        serverList.add(server);
+        connectorList.add(server);
+    }
+
+    protected void addClient(TrackerClient client) {
+        connectorList.add(client);
     }
 
     @Override
-    public Collection<TrackerServer> getServerList() {
-        return serverList;
+    public Collection<TrackerConnector> getConnectorList() {
+        return connectorList;
     }
 
     public void setSupportedDataCommands(String... commands) {
diff --git a/src/main/java/org/traccar/BaseProtocolPoller.java b/src/main/java/org/traccar/BaseProtocolPoller.java
new file mode 100644
index 000000000..88138577c
--- /dev/null
+++ b/src/main/java/org/traccar/BaseProtocolPoller.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.util.concurrent.Future;
+import org.traccar.config.Keys;
+
+import java.net.SocketAddress;
+import java.util.concurrent.TimeUnit;
+
+public abstract class BaseProtocolPoller extends ChannelDuplexHandler {
+
+    private final long interval;
+    private Future<?> timeout;
+
+    public BaseProtocolPoller(Protocol protocol) {
+        interval = Context.getConfig().getLong(Keys.PROTOCOL_INTERVAL.withPrefix(protocol.getName()));
+    }
+
+    protected abstract void sendRequest(Channel channel, SocketAddress remoteAddress);
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        super.channelActive(ctx);
+        if (interval > 0) {
+            timeout = ctx.executor().scheduleAtFixedRate(
+                    () -> sendRequest(ctx.channel(), ctx.channel().remoteAddress()), 0, interval, TimeUnit.SECONDS);
+        }
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+        super.channelInactive(ctx);
+        if (timeout != null) {
+            timeout.cancel(false);
+            timeout = null;
+        }
+    }
+
+}
diff --git a/src/main/java/org/traccar/Protocol.java b/src/main/java/org/traccar/Protocol.java
index aea69b353..bc9c99557 100644
--- a/src/main/java/org/traccar/Protocol.java
+++ b/src/main/java/org/traccar/Protocol.java
@@ -25,7 +25,7 @@ public interface Protocol {
 
     String getName();
 
-    Collection<TrackerServer> getServerList();
+    Collection<TrackerConnector> getConnectorList();
 
     Collection<String> getSupportedDataCommands();
 
diff --git a/src/main/java/org/traccar/ServerManager.java b/src/main/java/org/traccar/ServerManager.java
index 935a821aa..0db786bdb 100644
--- a/src/main/java/org/traccar/ServerManager.java
+++ b/src/main/java/org/traccar/ServerManager.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 - 2020 Anton Tananaev (anton@traccar.org)
+ * Copyright 2012 - 2022 Anton Tananaev (anton@traccar.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@ import org.traccar.config.Keys;
 import java.io.File;
 import java.io.IOException;
 import java.net.BindException;
+import java.net.ConnectException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
@@ -39,7 +40,7 @@ public class ServerManager {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ServerManager.class);
 
-    private final List<TrackerServer> serverList = new LinkedList<>();
+    private final List<TrackerConnector> connectorList = new LinkedList<>();
     private final Map<String, BaseProtocol> protocolList = new ConcurrentHashMap<>();
 
     private void loadPackage(String packageName) throws IOException, URISyntaxException, ReflectiveOperationException {
@@ -75,7 +76,7 @@ public class ServerManager {
             if (BaseProtocol.class.isAssignableFrom(protocolClass) && Context.getConfig().hasKey(
                     Keys.PROTOCOL_PORT.withPrefix(BaseProtocol.nameFromClass(protocolClass)))) {
                 BaseProtocol protocol = (BaseProtocol) protocolClass.getDeclaredConstructor().newInstance();
-                serverList.addAll(protocol.getServerList());
+                connectorList.addAll(protocol.getConnectorList());
                 protocolList.put(protocol.getName(), protocol);
             }
         }
@@ -90,18 +91,20 @@ public class ServerManager {
     }
 
     public void start() throws Exception {
-        for (TrackerServer server: serverList) {
+        for (TrackerConnector connector: connectorList) {
             try {
-                server.start();
+                connector.start();
             } catch (BindException e) {
-                LOGGER.warn("Port {} is disabled due to conflict", server.getPort());
+                LOGGER.warn("Port disabled due to conflict", e);
+            } catch (ConnectException e) {
+                LOGGER.warn("Connection failed", e);
             }
         }
     }
 
     public void stop() {
-        for (TrackerServer server: serverList) {
-            server.stop();
+        for (TrackerConnector connector: connectorList) {
+            connector.stop();
         }
         GlobalTimer.release();
     }
diff --git a/src/main/java/org/traccar/TrackerClient.java b/src/main/java/org/traccar/TrackerClient.java
new file mode 100644
index 000000000..dda02f909
--- /dev/null
+++ b/src/main/java/org/traccar/TrackerClient.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.channel.group.DefaultChannelGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import io.netty.util.concurrent.GlobalEventExecutor;
+import org.traccar.config.Keys;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import java.util.concurrent.TimeUnit;
+
+public abstract class TrackerClient implements TrackerConnector {
+
+    private final boolean secure;
+    private final long interval;
+
+    private final Bootstrap bootstrap;
+
+    private final int port;
+    private final String address;
+    private final String[] devices;
+
+    private final ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
+
+    @Override
+    public boolean isDatagram() {
+        return false;
+    }
+
+    @Override
+    public boolean isSecure() {
+        return secure;
+    }
+
+    public TrackerClient(String protocol) {
+
+        secure = Context.getConfig().getBoolean(Keys.PROTOCOL_SSL.withPrefix(protocol));
+        interval = Context.getConfig().getLong(Keys.PROTOCOL_INTERVAL.withPrefix(protocol));
+        address = Context.getConfig().getString(Keys.PROTOCOL_ADDRESS.withPrefix(protocol));
+        port = Context.getConfig().getInteger(Keys.PROTOCOL_PORT.withPrefix(protocol), secure ? 443 : 80);
+        devices = Context.getConfig().getString(Keys.PROTOCOL_DEVICES.withPrefix(protocol)).split("[, ]");
+
+        BasePipelineFactory pipelineFactory = new BasePipelineFactory(this, protocol) {
+            @Override
+            protected void addTransportHandlers(PipelineBuilder pipeline) {
+                try {
+                    if (isSecure()) {
+                        SSLEngine engine = SSLContext.getDefault().createSSLEngine();
+                        engine.setUseClientMode(true);
+                        pipeline.addLast(new SslHandler(engine));
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+
+            @Override
+            protected void addProtocolHandlers(PipelineBuilder pipeline) {
+                try {
+                    TrackerClient.this.addProtocolHandlers(pipeline);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+
+        bootstrap = new Bootstrap()
+                .group(EventLoopGroupFactory.getWorkerGroup())
+                .channel(NioSocketChannel.class)
+                .handler(pipelineFactory);
+    }
+
+    protected abstract void addProtocolHandlers(PipelineBuilder pipeline) throws Exception;
+
+    public String[] getDevices() {
+        return devices;
+    }
+
+    @Override
+    public ChannelGroup getChannelGroup() {
+        return channelGroup;
+    }
+
+    @Override
+    public void start() throws Exception {
+        bootstrap.connect(address, port)
+                .syncUninterruptibly().channel().closeFuture().addListener(new GenericFutureListener<>() {
+                    @Override
+                    public void operationComplete(Future<? super Void> future) {
+                        if (interval > 0) {
+                            GlobalEventExecutor.INSTANCE.schedule(() -> {
+                                bootstrap.connect(address, port)
+                                        .syncUninterruptibly().channel().closeFuture().addListener(this);
+                            }, interval, TimeUnit.SECONDS);
+                        }
+                    }
+                });
+    }
+
+    @Override
+    public void stop() {
+        channelGroup.close().awaitUninterruptibly();
+    }
+
+}
diff --git a/src/main/java/org/traccar/TrackerConnector.java b/src/main/java/org/traccar/TrackerConnector.java
new file mode 100644
index 000000000..9e2d27ae5
--- /dev/null
+++ b/src/main/java/org/traccar/TrackerConnector.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 - 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar;
+
+import io.netty.channel.group.ChannelGroup;
+
+public interface TrackerConnector {
+
+    boolean isDatagram();
+
+    boolean isSecure();
+
+    ChannelGroup getChannelGroup();
+
+    void start() throws Exception;
+
+    void stop();
+
+}
diff --git a/src/main/java/org/traccar/TrackerServer.java b/src/main/java/org/traccar/TrackerServer.java
index 59ba123e2..8e2fce616 100644
--- a/src/main/java/org/traccar/TrackerServer.java
+++ b/src/main/java/org/traccar/TrackerServer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 - 2018 Anton Tananaev (anton@traccar.org)
+ * Copyright 2012 - 2022 Anton Tananaev (anton@traccar.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,28 +23,58 @@ import io.netty.channel.group.ChannelGroup;
 import io.netty.channel.group.DefaultChannelGroup;
 import io.netty.channel.socket.nio.NioDatagramChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.handler.ssl.SslHandler;
 import io.netty.util.concurrent.GlobalEventExecutor;
 import org.traccar.config.Keys;
 
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
 import java.net.InetSocketAddress;
 
-public abstract class TrackerServer {
+public abstract class TrackerServer implements TrackerConnector {
 
     private final boolean datagram;
+    private final boolean secure;
+
+    @SuppressWarnings("rawtypes")
     private final AbstractBootstrap bootstrap;
 
+    private final int port;
+    private final String address;
+
+    private final ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
+
+    @Override
     public boolean isDatagram() {
         return datagram;
     }
 
+    @Override
+    public boolean isSecure() {
+        return secure;
+    }
+
     public TrackerServer(boolean datagram, String protocol) {
         this.datagram = datagram;
 
+        secure = Context.getConfig().getBoolean(Keys.PROTOCOL_SSL.withPrefix(protocol));
         address = Context.getConfig().getString(Keys.PROTOCOL_ADDRESS.withPrefix(protocol));
         port = Context.getConfig().getInteger(Keys.PROTOCOL_PORT.withPrefix(protocol));
 
         BasePipelineFactory pipelineFactory = new BasePipelineFactory(this, protocol) {
             @Override
+            protected void addTransportHandlers(PipelineBuilder pipeline) {
+                try {
+                    if (isSecure()) {
+                        SSLEngine engine = SSLContext.getDefault().createSSLEngine();
+                        pipeline.addLast(new SslHandler(engine));
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }
+
+            @Override
             protected void addProtocolHandlers(PipelineBuilder pipeline) {
                 TrackerServer.this.addProtocolHandlers(pipeline);
             }
@@ -52,14 +82,14 @@ public abstract class TrackerServer {
 
         if (datagram) {
 
-            this.bootstrap = new Bootstrap()
+            bootstrap = new Bootstrap()
                     .group(EventLoopGroupFactory.getWorkerGroup())
                     .channel(NioDatagramChannel.class)
                     .handler(pipelineFactory);
 
         } else {
 
-            this.bootstrap = new ServerBootstrap()
+            bootstrap = new ServerBootstrap()
                     .group(EventLoopGroupFactory.getBossGroup(), EventLoopGroupFactory.getWorkerGroup())
                     .channel(NioServerSocketChannel.class)
                     .childHandler(pipelineFactory);
@@ -69,32 +99,20 @@ public abstract class TrackerServer {
 
     protected abstract void addProtocolHandlers(PipelineBuilder pipeline);
 
-    private int port;
-
     public int getPort() {
         return port;
     }
 
-    public void setPort(int port) {
-        this.port = port;
-    }
-
-    private String address;
-
     public String getAddress() {
         return address;
     }
 
-    public void setAddress(String address) {
-        this.address = address;
-    }
-
-    private final ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
-
+    @Override
     public ChannelGroup getChannelGroup() {
         return channelGroup;
     }
 
+    @Override
     public void start() throws Exception {
         InetSocketAddress endpoint;
         if (address == null) {
@@ -103,12 +121,13 @@ public abstract class TrackerServer {
             endpoint = new InetSocketAddress(address, port);
         }
 
-        Channel channel = bootstrap.bind(endpoint).sync().channel();
+        Channel channel = bootstrap.bind(endpoint).syncUninterruptibly().channel();
         if (channel != null) {
             getChannelGroup().add(channel);
         }
     }
 
+    @Override
     public void stop() {
         channelGroup.close().awaitUninterruptibly();
     }
diff --git a/src/main/java/org/traccar/config/Keys.java b/src/main/java/org/traccar/config/Keys.java
index e8e0ff207..cb3bd4de8 100644
--- a/src/main/java/org/traccar/config/Keys.java
+++ b/src/main/java/org/traccar/config/Keys.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 - 2021 Anton Tananaev (anton@traccar.org)
+ * Copyright 2019 - 2022 Anton Tananaev (anton@traccar.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,6 +38,28 @@ public final class Keys {
             Collections.singletonList(KeyType.GLOBAL));
 
     /**
+     * List of devices for polling protocols. List should contain unique ids separated by commas. Used only for polling
+     * protocols.
+     */
+    public static final ConfigSuffix<String> PROTOCOL_DEVICES = new ConfigSuffix<>(
+            ".devices",
+            Collections.singletonList(KeyType.GLOBAL));
+
+    /**
+     * Polling interval in seconds. Used only for polling protocols.
+     */
+    public static final ConfigSuffix<Long> PROTOCOL_INTERVAL = new ConfigSuffix<>(
+            ".interval",
+            Collections.singletonList(KeyType.GLOBAL));
+
+    /**
+     * Enable SSL support for the protocol. Not all protocols support this.
+     */
+    public static final ConfigSuffix<Boolean> PROTOCOL_SSL = new ConfigSuffix<>(
+            ".ssl",
+            Collections.singletonList(KeyType.GLOBAL));
+
+    /**
      * Connection timeout value in seconds. Because sometimes there is no way to detect lost TCP connection old
      * connections stay in open state. On most systems there is a limit on number of open connection, so this leads to
      * problems with establishing new connections when number of devices is high or devices data connections are
@@ -176,6 +198,20 @@ public final class Keys {
             Collections.singletonList(KeyType.GLOBAL));
 
     /**
+     * ORBCOMM API access id.
+     */
+    public static final ConfigKey<String> ORBCOMM_ACCESS_ID = new ConfigKey<>(
+            "orbcomm.accessId",
+            Collections.singletonList(KeyType.GLOBAL));
+
+    /**
+     * ORBCOMM API password.
+     */
+    public static final ConfigKey<String> ORBCOMM_PASSWORD = new ConfigKey<>(
+            "orbcomm.password",
+            Collections.singletonList(KeyType.GLOBAL));
+
+    /**
      * Skip device connection session cache. Global configuration.
      */
     public static final ConfigKey<Boolean> DECODER_IGNORE_SESSIONS_CACHE = new ConfigKey<>(
diff --git a/src/main/java/org/traccar/handler/OpenChannelHandler.java b/src/main/java/org/traccar/handler/OpenChannelHandler.java
index d09d617ab..e416f35ae 100644
--- a/src/main/java/org/traccar/handler/OpenChannelHandler.java
+++ b/src/main/java/org/traccar/handler/OpenChannelHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Anton Tananaev (anton@traccar.org)
+ * Copyright 2019 - 2021 Anton Tananaev (anton@traccar.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,26 +17,26 @@ package org.traccar.handler;
 
 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandlerContext;
-import org.traccar.TrackerServer;
+import org.traccar.TrackerConnector;
 
 public class OpenChannelHandler extends ChannelDuplexHandler {
 
-    private final TrackerServer server;
+    private final TrackerConnector connector;
 
-    public OpenChannelHandler(TrackerServer server) {
-        this.server = server;
+    public OpenChannelHandler(TrackerConnector connector) {
+        this.connector = connector;
     }
 
     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {
         super.channelActive(ctx);
-        server.getChannelGroup().add(ctx.channel());
+        connector.getChannelGroup().add(ctx.channel());
     }
 
     @Override
     public void channelInactive(ChannelHandlerContext ctx) throws Exception {
         super.channelInactive(ctx);
-        server.getChannelGroup().remove(ctx.channel());
+        connector.getChannelGroup().remove(ctx.channel());
     }
 
 }
diff --git a/src/main/java/org/traccar/protocol/OrbcommProtocol.java b/src/main/java/org/traccar/protocol/OrbcommProtocol.java
new file mode 100644
index 000000000..bdfce3b1e
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/OrbcommProtocol.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar.protocol;
+
+import io.netty.handler.codec.http.HttpObjectAggregator;
+import io.netty.handler.codec.http.HttpRequestEncoder;
+import io.netty.handler.codec.http.HttpResponseDecoder;
+import org.traccar.BaseProtocol;
+import org.traccar.PipelineBuilder;
+import org.traccar.TrackerClient;
+
+public class OrbcommProtocol extends BaseProtocol {
+
+    public OrbcommProtocol() {
+        addClient(new TrackerClient(getName()) {
+            @Override
+            protected void addProtocolHandlers(PipelineBuilder pipeline) {
+                pipeline.addLast(new HttpRequestEncoder());
+                pipeline.addLast(new HttpResponseDecoder());
+                pipeline.addLast(new HttpObjectAggregator(65535));
+                pipeline.addLast(new OrbcommProtocolDecoder(OrbcommProtocol.this));
+                pipeline.addLast(new OrbcommProtocolPoller(OrbcommProtocol.this));
+            }
+        });
+    }
+
+}
diff --git a/src/main/java/org/traccar/protocol/OrbcommProtocolDecoder.java b/src/main/java/org/traccar/protocol/OrbcommProtocolDecoder.java
new file mode 100644
index 000000000..8f828beff
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/OrbcommProtocolDecoder.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar.protocol;
+
+import io.netty.channel.Channel;
+import io.netty.handler.codec.http.FullHttpResponse;
+import org.traccar.BasePipelineFactory;
+import org.traccar.BaseProtocolDecoder;
+import org.traccar.Protocol;
+
+import javax.json.Json;
+import javax.json.JsonObject;
+import java.io.StringReader;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.TimeZone;
+
+public class OrbcommProtocolDecoder extends BaseProtocolDecoder {
+
+    public OrbcommProtocolDecoder(Protocol protocol) {
+        super(protocol);
+    }
+
+    @Override
+    protected Object decode(
+            Channel channel, SocketAddress remoteAddress, Object msg) throws Exception {
+
+        FullHttpResponse response = (FullHttpResponse) msg;
+        String content = response.content().toString(StandardCharsets.UTF_8);
+        JsonObject json = Json.createReader(new StringReader(content)).readObject();
+
+        OrbcommProtocolPoller poller = BasePipelineFactory.getHandler(channel.pipeline(), OrbcommProtocolPoller.class);
+        if (poller != null) {
+            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+            poller.setStartTime(dateFormat.parse(json.getString("NextStartUTC")));
+        }
+
+        return null;
+    }
+
+}
diff --git a/src/main/java/org/traccar/protocol/OrbcommProtocolPoller.java b/src/main/java/org/traccar/protocol/OrbcommProtocolPoller.java
new file mode 100644
index 000000000..87fa039e1
--- /dev/null
+++ b/src/main/java/org/traccar/protocol/OrbcommProtocolPoller.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2022 Anton Tananaev (anton@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar.protocol;
+
+import io.netty.buffer.Unpooled;
+import io.netty.channel.Channel;
+import io.netty.handler.codec.http.DefaultFullHttpRequest;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.HttpVersion;
+import io.netty.handler.codec.http.QueryStringEncoder;
+import org.traccar.BaseProtocolPoller;
+import org.traccar.Context;
+import org.traccar.Protocol;
+import org.traccar.config.Keys;
+
+import java.net.SocketAddress;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+public class OrbcommProtocolPoller extends BaseProtocolPoller {
+
+    private final String accessId;
+    private final String password;
+
+    private Date startTime = new Date();
+
+    public void setStartTime(Date startTime) {
+        this.startTime = startTime;
+    }
+
+    public OrbcommProtocolPoller(Protocol protocol) {
+        super(protocol);
+        accessId = Context.getConfig().getString(Keys.ORBCOMM_ACCESS_ID);
+        password = Context.getConfig().getString(Keys.ORBCOMM_PASSWORD);
+    }
+
+    @Override
+    protected void sendRequest(Channel channel, SocketAddress remoteAddress) {
+
+        QueryStringEncoder encoder = new QueryStringEncoder("/GLGW/2/RestMessages.svc/JSON/get_return_messages/");
+        encoder.addParam("access_id", accessId);
+        encoder.addParam("password", password);
+
+        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+        encoder.addParam("start_utc", dateFormat.format(startTime));
+
+        HttpRequest request = new DefaultFullHttpRequest(
+                HttpVersion.HTTP_1_1, HttpMethod.POST, encoder.toString(), Unpooled.buffer());
+        channel.writeAndFlush(request);
+    }
+
+}