Notification SignalR Push dans les mobiles Android

Question

J'ai développé une application de chat en utilisant SignalR. Actuellement, je déplace ce code vers WebAPI pour une application Android,

Lorsqu'un utilisateur envoie un message à un utilisateur Android, je veux afficher des notifications push sur les mobiles Android. Est-il possible d'utiliser SignalR comme client dans une application Android?

Je suis vu certaines des références en ligne comme google GCm, ShaperChat mais je ne les comprends pas.

Answer 1

Oui, vous pouvez utiliser signalR dans votre application android. Mais cela vaudra la peine de configurer votre application pour utiliser signalR quand il est au premier plan et ensuite utiliser la notification push firebase lorsque l'application s'exécute en arrière-plan car votre connexion signalR peut être déconnectée et votre signalR ne fonctionnera pas. Ainsi, lorsque l'application est en cours d'exécution, vous devez utiliser signalR sinon utiliser firebase notificaiton system car Firebase utilise google play service qui sera toujours en cours d'exécution sur un périphérique.

Une simple mise en œuvre signalR https://github.com/ngocchung/SimpleSignalRClient

Answer 2

Oui, vous pouvez. Tout d'abord, assurez-vous que votre service SignalR fonctionne correctement et notez votre connexion token et hub, nom du groupe à partir duquel vous pouvez vous abonner à ces appels en les invoquant.

1) a fait une classe singleton

public class SignalRSingleton { 

private static SignalRSingleton mInstance = null; 
public HubConnection mHubConnection; 
public HubProxy mHubProxy; 

public static SignalRSingleton getInstance(){ 
    if(mInstance == null) 
    { 
     mInstance = new SignalRSingleton(); 
    } 
    return mInstance; 
} 

public void setmHubConnection() 
{ 
    String serverUrl = "http://192.168.1.5:8089/XM/"; 
    //String serverUrl = "http://192.168.1.184/test"; 
    mHubConnection = new HubConnection(serverUrl); 
} 

public void setHubProxy() 
{ 
    /* Credentials credentials = new Credentials() { 
     @Override 
     public void prepareRequest(Request request) { 
      request.addHeader("User-Name", MainActivity.unm); 
     } 
    };*/ 

    //mHubConnection.setCredentials(credentials); 
    String SERVER_HUB_CHAT = "messages"; 
    //String SERVER_HUB_CHAT = "Chat"; 
    mHubProxy = mHubConnection.createHubProxy(SERVER_HUB_CHAT); 
} 


/** 
* method for clients (activities) 
*/ 
public void sendMessage(String name , String message) { 

    String str = "{'RequestMessage':{'PID':'lr1','Password':'GIefhSIC5iBCnxioufbwEw == '},'RequestType':'Login'}"; 
    String SERVER_METHOD_SEND = "getMessage"; 
    //String SERVER_METHOD_SEND = "Send"; 
    mHubProxy.invoke(SERVER_METHOD_SEND,str); 
    } 
} 

2) Ensuite, mettre en œuvre un service

public class SignalRService extends Service { 
    //private HubConnection mHubConnection; 
    //private HubProxy mHubProxy; 
    private Handler mHandler; // to display Toast message 
    private final IBinder mBinder = new LocalBinder(); // Binder given to clients 
    private SignalRSingleton mInstance; 
    final static String MY_ACTION = "MY_ACTION"; 
    public SignalRService() { 

    } 
@Override 
public void onCreate() { 
    super.onCreate(); 
    mInstance = SignalRSingleton.getInstance(); 
    mHandler = new Handler(Looper.getMainLooper()); 
} 

@Override 
public int onStartCommand(Intent intent, int flags, int startId) { 
    int result = super.onStartCommand(intent, flags, startId); 
    startSignalR(); 
    return result; 
} 

@Override 
public void onDestroy() { 
    mInstance.mHubConnection.stop(); 
    super.onDestroy(); 
} 

@Override 
public IBinder onBind(Intent intent) { 
    // Return the communication channel to the service. 
    startSignalR(); 
    return mBinder; 
} 

/** 
* Class used for the client Binder. Because we know this service always 
* runs in the same process as its clients, we don't need to deal with IPC. 
*/ 
public class LocalBinder extends Binder { 
    public SignalRService getService() { 
     // Return this instance of SignalRService so clients can call public methods 
     return SignalRService.this; 
    } 
} 


/** 
* method for clients (activities) 
*/ 


private void startSignalR() { 
    Platform.loadPlatformComponent(new AndroidPlatformComponent()); 
    mInstance.setmHubConnection(); 
    mInstance.setHubProxy(); 
    ClientTransport clientTransport = new ServerSentEventsTransport(mInstance.mHubConnection.getLogger()); 
    SignalRFuture<Void> signalRFuture = mInstance.mHubConnection.start(clientTransport); 

    try { 
     signalRFuture.get(); 
    } catch (InterruptedException | ExecutionException e) { 
     Log.e("SimpleSignalR", e.toString()); 
     return; 
    } 

    mInstance.sendMessage(MainActivity.unm,"Hello All!"); 

    String CLIENT_METHOD_BROADAST_MESSAGE = "recievedMessage"; 
    //String CLIENT_METHOD_BROADAST_MESSAGE = "messageReceived"; 
    mInstance.mHubProxy.on(CLIENT_METHOD_BROADAST_MESSAGE, 
      new SubscriptionHandler2<String,LoginInfo>() { 
       @Override 
       public void run(final String msg,final LoginInfo loginInfo) { 
        final String finalMsg = loginInfo.FullName + " says " + loginInfo.Password; 
        Intent intent = new Intent(); 
        intent.setAction(MY_ACTION); 
        intent.putExtra("DATAPASSED", finalMsg); 
        sendBroadcast(intent); 
       } 
      } 
      , String.class,LoginInfo.class); 
} 
} 

Une fois que vous obtiendrez des appels de service Espérons que vous obtiendrez ce que vous avez besoin.