Merge pull request #326 from Backendless/real-time

Real time
Backendless · Jun 4, 2018 · 59069d9 · 59069d9
2 parents ea10bd0 + 822a7f5
commit 59069d9
Show file tree

Hide file tree

Showing 65 changed files with 4,171 additions and 246 deletions.
diff --git a/build.gradle b/build.gradle
@@ -5,7 +5,7 @@ apply plugin: 'signing'
 
 
 group 'com.backendless'
-version '4.5.0-snapshot'
+version '4.5.1-real-time-snapshot'
 archivesBaseName='backendless'
 
 
@@ -230,5 +230,10 @@ dependencies {
     }
     compile( group: "weborb", name: "weborbclient", version: "5.1.0.212", changing: true)
 
+    compileOnly ('io.socket:socket.io-client:1.0.0') {
+//       excluding org.json which is provided by Android
+      exclude group: 'org.json', module: 'json'
+    }
 }
+
 apply plugin: 'java'
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,6 @@
+#Wed Mar 21 17:39:57 EET 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-all.zip
diff --git a/src/com/backendless/Backendless.java b/src/com/backendless/Backendless.java
@@ -32,6 +32,8 @@
 import com.backendless.persistence.RealmSerializer;
 import com.backendless.persistence.local.UserIdStorageFactory;
 import com.backendless.persistence.local.UserTokenStorageFactory;
+import com.backendless.rt.RTService;
+import com.backendless.rt.RTServiceImpl;
 import weborb.ORBConstants;
 import weborb.config.ORBConfig;
 import weborb.util.ObjectFactories;
@@ -67,6 +69,7 @@ public final class Backendless
   public static final Counters Counters = com.backendless.Counters.getInstance();
   public static final CustomService CustomService = com.backendless.CustomService.getInstance();
   public static final Logging Logging = com.backendless.Logging.getInstance();
+  public static final RTService RT = new RTServiceImpl();
   public static Media Media;
   private static boolean initialized;
 

diff --git a/src/com/backendless/DataStoreFactory.java b/src/com/backendless/DataStoreFactory.java
@@ -23,6 +23,8 @@
 import com.backendless.persistence.BackendlessSerializer;
 import com.backendless.persistence.DataQueryBuilder;
 import com.backendless.persistence.LoadRelationsQueryBuilder;
+import com.backendless.rt.data.EventHandler;
+import com.backendless.rt.data.EventHandlerFactory;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -32,11 +34,14 @@
 class DataStoreFactory
 {
   private static final List<String> emptyRelations = new ArrayList<String>();
+  private final static EventHandlerFactory eventHandlerFactory = new EventHandlerFactory();
 
   protected static <E> IDataStore<E> createDataStore( final Class<E> entityClass )
   {
+
     return new IDataStore<E>()
     {
+      private EventHandler<E> eventHandler = eventHandlerFactory.of( entityClass );
 
       @Override
       public List<String> create( List<E> objects ) throws BackendlessException
@@ -538,6 +543,12 @@ public void deleteRelation( E parent, String relationColumnName, String whereCla
         Object[] args = new Object[] { parentTableName, relationColumnName, parentObjectId, whereClause };
         Invoker.invokeAsync( Persistence.PERSISTENCE_MANAGER_SERVER_ALIAS, "deleteRelation", args, callback );
       }
+
+      @Override
+      public EventHandler<E> rt()
+      {
+        return eventHandler;
+      }
     };
   }
 }
diff --git a/src/com/backendless/IDataStore.java b/src/com/backendless/IDataStore.java
@@ -22,6 +22,7 @@
 import com.backendless.exceptions.BackendlessException;
 import com.backendless.persistence.DataQueryBuilder;
 import com.backendless.persistence.LoadRelationsQueryBuilder;
+import com.backendless.rt.data.EventHandler;
 
 import java.util.Collection;
 import java.util.List;
@@ -169,4 +170,6 @@ public interface IDataStore<E>
   int deleteRelation( E parent, String relationColumnName, String whereClause );
 
   void deleteRelation( E parent, String relationColumnName, String whereClause, AsyncCallback<Integer> callback );
+
+  EventHandler<E> rt();
 }
diff --git a/src/com/backendless/Messaging.java b/src/com/backendless/Messaging.java
@@ -51,6 +51,8 @@
 import com.backendless.messaging.PushBroadcastMask;
 import com.backendless.messaging.SubscriptionOptions;
 import com.backendless.push.GCMRegistrar;
+import com.backendless.rt.messaging.Channel;
+import com.backendless.rt.messaging.ChannelFactory;
 import weborb.types.Types;
 
 import java.util.ArrayList;
@@ -69,6 +71,7 @@ public final class Messaging
   private final static String OS;
   private final static String OS_VERSION;
   private static final Messaging instance = new Messaging();
+  private static final ChannelFactory chanelFactory = new ChannelFactory();
 
   private Messaging()
   {
@@ -614,173 +617,14 @@ public void cancel( String messageId, AsyncCallback<MessageStatus> responder )
     }
   }
 
-  public Subscription subscribe( AsyncCallback<List<Message>> subscriptionResponder ) throws BackendlessException
+  public Channel subscribe( )
   {
-    return subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, null, 0 );
+      return subscribe( "default" );
   }
 
-  public Subscription subscribe( String channelName, AsyncCallback<List<Message>> subscriptionResponder,
-                                 SubscriptionOptions subscriptionOptions,
-                                 int pollingInterval ) throws BackendlessException
+  public Channel subscribe( String channelName )
   {
-    checkChannelName( channelName );
-
-    if( pollingInterval < 0 )
-      throw new IllegalArgumentException( ExceptionMessage.WRONG_POLLING_INTERVAL );
-
-    String subscriptionId = subscribeForPollingAccess( channelName, subscriptionOptions );
-
-    Subscription subscription = new Subscription();
-    subscription.setChannelName( channelName );
-    subscription.setSubscriptionId( subscriptionId );
-
-    if( pollingInterval != 0 )
-      subscription.setPollingInterval( pollingInterval );
-
-    subscription.onSubscribe( subscriptionResponder );
-
-    return subscription;
-  }
-
-  private String subscribeForPollingAccess( String channelName,
-                                            SubscriptionOptions subscriptionOptions ) throws BackendlessException
-  {
-    if( channelName == null )
-      throw new IllegalArgumentException( ExceptionMessage.NULL_CHANNEL_NAME );
-
-    if( subscriptionOptions == null )
-      subscriptionOptions = new SubscriptionOptions();
-
-    return Invoker.invokeSync( MESSAGING_MANAGER_SERVER_ALIAS, "subscribeForPollingAccess", new Object[] { channelName, subscriptionOptions } );
-  }
-
-  public Subscription subscribe( String channelName,
-                                 AsyncCallback<List<Message>> subscriptionResponder ) throws BackendlessException
-  {
-    return subscribe( channelName, subscriptionResponder, null, 0 );
-  }
-
-  public Subscription subscribe( int pollingInterval,
-                                 AsyncCallback<List<Message>> subscriptionResponder ) throws BackendlessException
-  {
-    return subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, null, pollingInterval );
-  }
-
-  public Subscription subscribe( String channelName, int pollingInterval,
-                                 AsyncCallback<List<Message>> subscriptionResponder ) throws BackendlessException
-  {
-    return subscribe( channelName, subscriptionResponder, null, pollingInterval );
-  }
-
-  public Subscription subscribe( AsyncCallback<List<Message>> subscriptionResponder,
-                                 SubscriptionOptions subscriptionOptions ) throws BackendlessException
-  {
-    return subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, subscriptionOptions, 0 );
-  }
-
-  public Subscription subscribe( String channelName, AsyncCallback<List<Message>> subscriptionResponder,
-                                 SubscriptionOptions subscriptionOptions ) throws BackendlessException
-  {
-    return subscribe( channelName, subscriptionResponder, subscriptionOptions, 0 );
-  }
-
-  public void subscribe( AsyncCallback<List<Message>> subscriptionResponder, AsyncCallback<Subscription> responder )
-  {
-    subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, null, 0, responder );
-  }
-
-  public void subscribe( final String channelName, final AsyncCallback<List<Message>> subscriptionResponder,
-                         SubscriptionOptions subscriptionOptions, final int pollingInterval,
-                         final AsyncCallback<Subscription> responder )
-  {
-    try
-    {
-      checkChannelName( channelName );
-
-      if( pollingInterval < 0 )
-        throw new IllegalArgumentException( ExceptionMessage.WRONG_POLLING_INTERVAL );
-
-      subscribeForPollingAccess( channelName, subscriptionOptions, new AsyncCallback<String>()
-      {
-        @Override
-        public void handleResponse( String subscriptionId )
-        {
-          Subscription subscription = new Subscription();
-          subscription.setChannelName( channelName );
-          subscription.setSubscriptionId( subscriptionId );
-
-          if( pollingInterval != 0 )
-            subscription.setPollingInterval( pollingInterval );
-
-          subscription.onSubscribe( subscriptionResponder );
-
-          if( responder != null )
-            responder.handleResponse( subscription );
-        }
-
-        @Override
-        public void handleFault( BackendlessFault fault )
-        {
-          if( responder != null )
-            responder.handleFault( fault );
-        }
-      } );
-    }
-    catch( Throwable e )
-    {
-      if( responder != null )
-        responder.handleFault( new BackendlessFault( e ) );
-    }
-  }
-
-  private void subscribeForPollingAccess( String channelName, SubscriptionOptions subscriptionOptions,
-                                          AsyncCallback<String> responder )
-  {
-    try
-    {
-      if( channelName == null )
-        throw new IllegalArgumentException( ExceptionMessage.NULL_CHANNEL_NAME );
-
-      if( subscriptionOptions == null )
-        subscriptionOptions = new SubscriptionOptions();
-
-      Invoker.invokeAsync( MESSAGING_MANAGER_SERVER_ALIAS, "subscribeForPollingAccess", new Object[] { channelName, subscriptionOptions }, responder );
-    }
-    catch( Throwable e )
-    {
-      if( responder != null )
-        responder.handleFault( new BackendlessFault( e ) );
-    }
-  }
-
-  public void subscribe( String channelName, AsyncCallback<List<Message>> subscriptionResponder,
-                         AsyncCallback<Subscription> responder )
-  {
-    subscribe( channelName, subscriptionResponder, null, 0, responder );
-  }
-
-  public void subscribe( int pollingInterval, AsyncCallback<List<Message>> subscriptionResponder,
-                         AsyncCallback<Subscription> responder )
-  {
-    subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, null, pollingInterval, responder );
-  }
-
-  public void subscribe( String channelName, int pollingInterval, AsyncCallback<List<Message>> subscriptionResponder,
-                         AsyncCallback<Subscription> responder )
-  {
-    subscribe( channelName, subscriptionResponder, null, pollingInterval, responder );
-  }
-
-  public void subscribe( AsyncCallback<List<Message>> subscriptionResponder, SubscriptionOptions subscriptionOptions,
-                         AsyncCallback<Subscription> responder )
-  {
-    subscribe( DEFAULT_CHANNEL_NAME, subscriptionResponder, subscriptionOptions, 0, responder );
-  }
-
-  public void subscribe( String channelName, AsyncCallback<List<Message>> subscriptionResponder,
-                         SubscriptionOptions subscriptionOptions, AsyncCallback<Subscription> responder )
-  {
-    subscribe( channelName, subscriptionResponder, subscriptionOptions, 0, responder );
+    return chanelFactory.create( channelName );
   }
 
   public List<Message> pollMessages( String channelName, String subscriptionId ) throws BackendlessException

diff --git a/src/com/backendless/UserService.java b/src/com/backendless/UserService.java
@@ -29,6 +29,7 @@
 import com.backendless.persistence.local.UserTokenStorageFactory;
 import com.backendless.property.AbstractProperty;
 import com.backendless.property.UserProperty;
+import com.backendless.rt.RTClientFactory;
 import com.facebook.CallbackManager;
 import weborb.types.Types;
 
@@ -486,6 +487,7 @@ private void handleLogout()
     HeadersManager.getInstance().removeHeader( HeadersManager.HeadersEnum.USER_TOKEN_KEY );
     UserTokenStorageFactory.instance().getStorage().set( "" );
     UserIdStorageFactory.instance().getStorage().set( "" );
+    RTClientFactory.get().userLoggedOut();
   }
 
   public void logout( final AsyncCallback<Void> responder )
@@ -824,6 +826,8 @@ private void handleUserLogin( BackendlessUser invokeResult, boolean stayLoggedIn
       UserTokenStorageFactory.instance().getStorage().set( "" );
       UserIdStorageFactory.instance().getStorage().set( "" );
     }
+
+    RTClientFactory.get().userLoggedIn( userToken );
   }
 
   private AsyncCallback<BackendlessUser> getUserLoginAsyncHandler(

diff --git a/src/com/backendless/async/callback/Fault.java b/src/com/backendless/async/callback/Fault.java
@@ -0,0 +1,9 @@
+package com.backendless.async.callback;
+
+import com.backendless.exceptions.BackendlessFault;
+
+public interface Fault extends Result<BackendlessFault>
+{
+  @Override
+  void handle( BackendlessFault fault );
+}
diff --git a/src/com/backendless/async/callback/Result.java b/src/com/backendless/async/callback/Result.java
@@ -0,0 +1,6 @@
+package com.backendless.async.callback;
+
+public interface Result<T>
+{
+  void handle(T result);
+}
diff --git a/src/com/backendless/exceptions/BackendlessException.java b/src/com/backendless/exceptions/BackendlessException.java
@@ -118,6 +118,7 @@ public String toString()
     sb.append( "{ code: '" ).append( getCode() ).append( '\'' );
     sb.append( ", message: '" ).append( getMessage() ).append( '\'' );
     sb.append( ", extendedData: '").append( getExtendedData() ).append( '\'' );
+    sb.append( ", detail: '" ).append( getDetail() ).append( '\'' );
     sb.append( " }" );
     return sb.toString();
   }