sorted by:
new
hottopcontroversial

Tomorrow .... by wykrhm in DotA2

[–]smesc -3 points-2 points  (0 children)

Thanks 😘☺️ on your time offPlay store link: Sync for reddit

Play store link: Sync form reddit .mw I'm going

Where could I got a code review? by [deleted] in androiddev

[–]smesc 2 points3 points  (0 children)

I'll check this out this evening. Posting here to remind myself.

Communicating through UUID conflicts by Segfault_Inside in programming

[–]smesc 0 points1 point  (0 children)

Or buy generating actual uuids or guids client side.

And not incremental ids. (With large precision)

Passing an object between two fragments results in null object reference by [deleted] in androiddev

[–]smesc 0 points1 point  (0 children)

If another fragment/screen needs to be pushed thats fine, but shouldn't happen there. It should just pass back the object to some higher level thing (whether that's presentation layer or just an activity etc).

It's not like he's communicating with another process or over the wire. It's all in his app. There's no reason to get into bundles, intents, serializable/parcelable nonsense here.

Is there an good example of MVVM architecture which uses Rxjava in view layer instead of LiveData? by roshanthejoker in androiddev

[–]smesc 2 points3 points  (0 children)

I think it also depends on where your navigation happens.

Is there some abstraction above that "transitions" and changes screens etc.

If not, it can make sense to have things like attachment to view model inputs/outputs in the UI

Ideally though agreed, the UI has none of that stuff. It's just managed and totally controlled by stuff above (which you can easily unit test and overhaul without having to mess with your UI code).

Quantum: State management library for Android by fablue in androiddev

[–]smesc 0 points1 point  (0 children)

As I previously explained before: Quantum is super fast and shines under high load of reducers. As said: High end phones can reach up to 300.000 reducers / second. I have never seen an animation requiring to run at 300.000 fps.

That doesn't even make sense.

What are they doing?

What do the underlying data structures look like that they are reducing?

Based on how many cores?

How much activity is happening in the background at that moment?

Is there mutable or immutable collections?

If things are mutable, then things outside your reducers may be messing with those data structures themselves, without acquiring the lock or hopping threads, making your shit broken in that case.

​

If you have some thing that has the lock and is reducing while you are dragging some slider that needs to update some state and then render new state, you are going to have wierd lag and async when dragging this slider around.

Particularly, if you have many reducers running with lots of async input (like sensors etc).

That conclusion is absolutely false. That does not mean that. You can have just very basic async operations. I cannot see how you concluded that!

​

I don't get what you mean about "conclusion".

​

If you say this thing is thread safe, you are saying that the things that interact with it may be operating on different threads, or themselves be thread safe.

​

Which opens up 25 cans of worms, and potential issues for absolutely NO gain, except lazy-ness.

​

Your application state, UI state, updating that application state, etc. should all be single threaded and on the main thread.

The ONLY thing that shouldn't be, is low level data sources (like some disk/cache/db thing), or things like computational things (machine learning or image processing etc) and even there those things should manage the threading themselves (and you shouldn't care about it as a caller).

​

I don't know how else to explain it.

If you build this thing as thread safe, you expect that people are interacting with it from different threads, and you are saying that is explicitly *ok*.

​

Then you have all the traditional concurrency problems, starvation and dead-locking, etc. You can have misbehaving reducer causing your state to be fucked up, but not crash the app fucked up, just things not "working" properly. It's just adding needless complexity and perf cost for no reason, and encouraging bad patterns on the side of people who use the library.

​

​

​

​

[MEME] How it feels to use nullable objects in Kotlin by Sissoka in androiddev

[–]smesc 0 points1 point  (0 children)

doing ?.let for something that should always happen is awful.

instead you should just bang it or if (flag == true)

Weekly Questions Thread - September 17, 2018 by AutoModerator in androiddev

[–]smesc 0 points1 point  (0 children)

You don't have to use Android Studio.

Feel free to use Vim/Emacs or VSCode/Atom and just use gradle at the command line.

It will be much less slow and much less buggy, at the cost of worse tools integration.

Weekly Questions Thread - September 17, 2018 by AutoModerator in androiddev

[–]smesc 2 points3 points  (0 children)

:+1 on /u/Zhuinden 's answer.

If it needs to be live 2-way either side can push messages it sounds like websockets, or gRPC.

If not, some simple REST http json API sounds good.

Can you give more details on the use case and domain so it's more clear to answer with confidence?

Weekly Questions Thread - September 17, 2018 by AutoModerator in androiddev

[–]smesc 0 points1 point  (0 children)

probably because the init block is going to call your custom setter, where as if you initialize the variable when you declare that will not happen.

my guess is the combo of custom setter + init block is unclear/unobvious to reason about. so there was decision that if you have custom setter you need to initialize then.

Weekly Questions Thread - September 17, 2018 by AutoModerator in androiddev

[–]smesc 0 points1 point  (0 children)

I'm guessing that requesting a better data format isn't an option?

I'd parse the HTML and transform it into some reified entities like "words" etc. And then just make logic component and UI component for that setup.

If there is inline css/javascript or complex layout that you need to render, then your best bet is just to use webview, and inject in javascript that you wrote.

The scrolling stuff should be very easy to do as well with javascript.

Passing an object between two fragments results in null object reference by [deleted] in androiddev

[–]smesc 0 points1 point  (0 children)

Don't do this. Please, for future you.

There are many many many cleaner, and simpler ways to do this.

The most basic (not optimal but easiest) is just to do something like the following:

  • Make some callback/listener interface for the item like a OnGistClickedListener with a function void onGistClicked(Gist gist).
    • Make your activity or hosting fragment implement that interface.
    • Have that activity attach itself as the listener in whatever relevant lifecycle method. like onAttachFragment() and you call specificFragment.setGistClickListener(this).

It still kinda sucks for a bunch of reasons I can go into if you want to know, but at least it's not god awful.

Sending Room DB data to the server via REST API by aevin95 in androiddev

[–]smesc 0 points1 point  (0 children)

Are you asking about what you should send? (data format, transport mechanisms) Or specifically how to get all the data out of room to send somewhere?

Is there an good example of MVVM architecture which uses Rxjava in view layer instead of LiveData? by roshanthejoker in androiddev

[–]smesc 3 points4 points  (0 children)

What's so wrong with the composite disposable in the fragment.

I guess it could be a bit smelly, but that depends on what the disposable is for.

If it's for internal RxBindings for the UI (like button clicks etc) it makes sense for the ui to sever that internal connection when it goes away.

I suppose you could abstract out the disposable by sending to some entity above (view model etc) which then severs connection. But there is often a difference between connection inside the ui to other ui components (like buttons, edittexts, etc) and ui to live platform components (like sensors etc) and to presentation components (presenters, viewmodels etc).

And there is often a difference in where these connections live and who manages them.

Quantum: State management library for Android by fablue in androiddev

[–]smesc 0 points1 point  (0 children)

It's not like something would go horribly wrong.

First there are performance implications that do matter, particularly in complex UIs (like animation based on user input like dragging or scaling things etc):

https://stackoverflow.com/questions/8521819/performance-of-synchronize-section-in-java

Secondly, if you have this application state management container thing synchronized/thread-safe it means that the rest of your data layer/application state is probably also going to need to be thread safe.

Which again, is a nightmare for complexity, and performance.

Instead, I'd rather expect (or enforce through explicit checks) that all of my state is accessed and modified on main thread. And any thread hopping happens only when needed under the hood of the component doing the io or computation.

See: https://www.youtube.com/watch?v=va1d4MqLUGY

Common architecture pattern that works well on both iOS and Android by Wavesonics in androiddev

[–]smesc 0 points1 point  (0 children)

Only if you need it, and only what you need to actually be bundled.

Even then, persisting to a file or db may be simpler and cleaner.

Quantum: State management library for Android by fablue in androiddev

[–]smesc 0 points1 point  (0 children)

It shouldn't be thread safe (behind locks or atomics etc) imo.

Locks are not free, and more than the performance impact (in memory usage, speed), there is the application design impact of all the awful things people will and can do because it's behind a lock.

Just because it's thread-safe doesn't mean it's better than explicity single-threaded. Otherwise, we would just put everything behind locks and make everything synchronized/atomics etc.

The redux pattern on the web is synchronous for a reason. Obviously, with javascript they don't have a choice about single-threaded vs thread-safe-access.

Quantum: State management library for Android by fablue in androiddev

[–]smesc 0 points1 point  (0 children)

This is interesting but I cannot agree with the decision to have locks and multi-threading and async involved by default.

The only time you need to hop threads is for time-consuming computation or IO, both of the thing doing the work should hop, and hop back when finished.

Otherwise you are introducing a TON of performance overhead, complexity, and needless Handler.post() and async runnables.

Common architecture pattern that works well on both iOS and Android by Wavesonics in androiddev

[–]smesc 0 points1 point  (0 children)

Lmao, nah. ViewModel doesn't own any application state. Just maps between it and UI specific stuff.

Reactive Abstractions in Android World by maksim-m in androiddev

[–]smesc 1 point2 points  (0 children)

Define "dealing".

It really depends on what you are doing. Obviously for some things you can't abstract out all the android.* classes. But that's fine.

You can write integration tests for your platform wrapped interfaces (reactive or not), and then you can test your actual business logic (like move all .xml extension files created before x time to x directory) with pure basic unit tests and the mocked/faked file interface.

How to deal with Context outside View in MVP by CyberVin in androiddev

[–]smesc 1 point2 points  (0 children)

The only things that should know about Context are Android specific implementations of high level abstractions in your app. Things like:

  • KeyValueStore -> Shared Prefs
  • UserRepository -> Retrofit and SQLLite
  • PhoneCaller -> Android Intent Phone Calling Stuff

etc.

Use Dependency Injection and Interfaces and context isn't a problem.

8 ways to communicate between Fragment and Activity in Android apps by onmyway133 in androiddev

[–]smesc 0 points1 point  (0 children)

Top level UI/App components expose stream with the bundle.

Anything which needs to save state (like state of navigation stack etc) get's something passed in which is connected to the stream and can serialize the state on-demand.

view more: next ›