OwnBackup

ownbackup

Startups of The Year 2023 Winners: North America 

I will show how to do a of with backup your GitHub repositories python-github-backup Why to bother with a backup of GitHub I can already see that there will be comments regarding why to do the backup of . GitHub “It is a waste of time.” “GitHub internally already have backups.” (I hope so) “They will not lose your code” (But maybe I will) “They will not go overnight out of business.” Response to all those comments is: You will not be worst off if you have your own backup. If forever reason (GitHub go under, all repositories deleted by accident, alien attack) GitHub is not available anymore, I have my own backup of code that I have written. Paid solution If you are looking for a paid solution, looks like a good solution. I have no experience with BackHub, nor am I in any way associated with it. BackHub Free solution After researching I have decided to go with because it had more stars and contributors on GitHub than other projects. all available options python-github-backup I have used the number of stars and contributors on GitHub as the assumption that is more in use than other solutions so there are more people who will continue to support it in future. python-github-backup In order to access your GitHub personal data, you need to have a . personal access token After that, you can install it with : (I have installed it in separate virtualenv) pip/pipenv or pipenv install github-backup pip install github-backup Run it with: /full/path/github_backup/venv/bin/github-backup sasa-buklijas -t your_personal_access_token -o /full/path/github_backup --all This command will backup all your GitHub information to . /full/path/github_backup directory It would be tiresome to run this command every day, so I have automated it on . my online hosting Crontab My usecase: 15 00 * * * /full/path/github_backup/venv/bin/github-backup sasa-buklijas -t your_personal_access_token -o /full/path/github_backup --all > /full/path/github_backup/last_log.txt is used to have an output of the last backup command. can be used to have outputs of all backup commands, but I have found that having just last one is enough. > /full/path/github_backup/last_log.txt >> Conclusion “You will not be worse off if you have your own backup.” Do you have backups of your own personal GitHub repositories, if you have, what do you use for backup? Originally published at buklijas.info on August 1, 2018.

How to backup personal GitHub repositories

Thing of beauty…key component of antifragile grid. On the morning of December 2nd 2014 the power went out for ~100 buildings in downtown Detroit. People were stuck in elevators and railcars. Flights were grounded as the city airport also suffered from the outage. Traffic lights stopped working. A few hospitals were without electricity leaving patients plugged to devices that weren’t functioning as required. All city fire stations were without power. . A spokesman for the Mayor said the outage was ‘ . System shock starting in one location leading to total system failure. The Wayne county jail (with its own backup power) kept running as usual caused by extreme heat, cable failure and routine maintenance — all combining causing system overload On across Northeast US and Canada stopped functioning, resulting in a blackout that affected ~50M Americans and Canadians. . 3 minutes. 100 power plants went out over the course of the blackout with 50M people affected in total. People stuck in elevators, subway systems and without water due to non-functioning water pumps starved of electricity. All caused by a downed power line that was not reported because of a software bug that was not noticed by a control room engineer who couldn’t see there was a surge on the system. I take that back. All caused by our reliance on an electric grid with archaic machines, systems and processes unfit for the modern day requirements and capabilities of a power dependent populace. A non-adaptive system with one point of failure. System shock starting in one location leading to total system failure. August 14th 2003 about 100 power plants 21 power plants providing power to ~10M people went down in 3 minutes Right now (as I write this post) across the US there are at least 23 power outages affecting ~300k consumers (see image below) including Louisiana. Click on the image to view updated version. : Our grid is more fragile than we realize. This became more apparent to me after reading Gretchen Bakke’s ‘The Grid’. But this is an optimistic post. As fragile as the grid is, we already have the technology required to make it . It starts with seeing the possibility that occurrences like the acquisition of Solarcity by Tesla, even if it does not fully make financial sense right now, provide to the possibility of bringing grid resilience. But what is Anti-Fragility? Fragility of the grid antifragile All credit to the concept of goes to . antifragility Nassim Nicholas Taleb Seemingly abrasive and disdainful of people who falsely claim expertise, in his view, Nassim Taleb gave the world a new way to frame how systems that get stronger and benefit from chaos and volatility. He gave us a word for the opposite of ‘fragile’; . Even with this simple understanding of it’s easy to see that the electric grid system I’ve described in the two examples above is fragile. A problem with the approaches being taken to fix our fragile grid is that we are focused on building a grid, on building a grid that is capable of recovering quickly from difficulties or failure. This is the wrong approach. We need to build a grid that is one that grows stronger with the stresses and the chaos_._ But how does Tesla/Solarcity get us there? Antifragility is beyond resilience or robustness. The resilient resists shocks and stays the same; the antifragile gets better antifragility resilient antifragile, : Amidst all the noise about autonomous vehicles what the pundits miss is the antifragile system capacity that comes as a result of many This concept is called . In laymen’s terms; every autonomous vehicle that is driving thousands of the miles on the road is gaining knowledge, through machine learning, that improves the collective knowledge of every autonomous vehicle out there. When one autonomous vehicle experiences a shock, say an accident, even though the vehicle might have a little damage, the collective whole (the autonomous driving knowledge database) learns and improves. One vehicle, a node in the system, might have failed, but the whole system (adaptive system) has grown stronger from the shock to that node. Antifragile grid autonomous vehicles operating for a common purpose that are not centrally controlled. swarming Now replace ‘ node in the transport system with a ‘ ’ node on an grid. The same can be achieved, where a shock to one Tesla/Solarcity node does not cause the whole system to fail. In fact, the whole grid learns from the failure of that one node and grows stronger allocating resources dynamically. autonomous vehicle’ Tesla roadster/Tesla Powerwall/Solarcity panel antifragile antifragility Tesla Gigafactory (Image courtesy of ) https://www.tesla.com/gigafactory The Tesla battery pack and Powerwall, the real reasons why Elon is working on a gigafactory, combined with the solar panels from Solarcity start to move us towards this antifragile grid. The whole system will be managed by software (built by partners and competitors) that knows when you need power, where to pull it from (whether battery, solar panel or Powerwall) because of the price signal, seamlessly ensuring that you get your hot coffee to start your day or hot chocolate on a cold night. To take the example further, what this looks like in the future; One home with a Tesla/Solarcity system loses power. the grid identifies the reason for the failure (from its database) or adds the failure to its knowledge base. antifragile no other node on the grid fails, the system continues to function the antifragile grid learns from the failure and implements a fix/self-heals. the antifragile grid determines where there is excess capacity (a neighbor’s vehicle-to-grid enabled Tesla roadster) and powers up the failed node. The grid has become a stronger and smarter system waiting for the next failure to learn from… antifragile This cost $11,471 in today’s money in 1955!!! ].The price of a Tesla/Solarcity pack will come down to a point where it comes down to a price point that can be considered one for the mass market, it’s the path of most new consumer technology. The Tesla/Solarcity deal, are resisting and boohooing, starts to help our grid develop its ability to grow stronger from the shocks and chaos that comes with the adoption of more intermittent sources of energy like wind and solar. Yes, not everyone can afford a Tesla or solar panel right now, but we all know that will change. In 1955 the first home microwave oven that was introduced to the market by the Tappan Stove company cost $1295 [$11,471.91 in 2016 $’s!!! which a lot of people who understand financial statements but do not understand the state of the grid . What needs to happen is a full redesign of the grid to make it . What will we need, beyond the Tesla/Solarcity deal coming through to make this happen? We’ll need Elon Musk/Solarcity and his crew to open source some part of this system software, this will enable the tinkerers and developers out there to build AI and machine learning software at a scale that Tesla/Solarcity itself cannot build. We’ll need the utilities, who now have the chance at a new business model and a role to play in this grid future (where they didn’t have one before), to become a lot more transparent about how the infrastructure part of the current grid functions; this allows the Tesla/Solarcity’s of the world to ramp up their understanding of what it takes to be a provider of stable, secure and affordable power. The design is the flaw in the current utility system antifragile antifragile Bottom line? We all need this Tesla/Solarcity deal to come through, probably more than Elon Musk… For us to avoid system-wide power outages, that cripple humans and businesses, we’ll need companies that jump into providing the critical elements of renewable energy generation, storage and consumption management. At scale. But without the complexity of the present day grid system. Considering the size of Elon’s ambitions, that’s hoping for a lot…

Why We All Need Tesla/Solarcity To Happen aka Building An Antifragile Grid.

Building a Local AI Chatbot with LangChain4J and Ollama

Previously, I explained where only the DB binaries were corrupted. Now, let's try to fix a node with only the GRID binaries corrupted. how to fix a node My configuration
Oracle RAC with 2 nodes: ol8-19-rac1 and ol8-19-rac2
CDB: cdbrac1
PBD: pdb1

Grid Version
34318175;TOMCAT RELEASE UPDATE 19.0.0.0.0 (34318175)
34160635;OCW RELEASE UPDATE 19.16.0.0.0 (34160635)
34139601;ACFS RELEASE UPDATE 19.16.0.0.0 (34139601)
34133642;Database Release Update : 19.16.0.0.220719 (34133642)
33575402;DBWLM RELEASE UPDATE 19.0.0.0.0 (33575402)

DB Version
34086870;OJVM RELEASE UPDATE: 19.16.0.0.220719 (34086870)
34160635;OCW RELEASE UPDATE 19.16.0.0.0 (34160635)
34133642;Database Release Update : 19.16.0.0.220719 (34133642)

When you see <dbenv>, load the DB HOME variables.
When you see <gridenv>, load the GRID HOME variables.

When you see <bnode>, execute the command on the broken node.
When you see <anode>, execute the command on any other working node. I am using an installation where both DB and GRID are installed under the user ORACLE, and I set the variables to access each environment. But the same procedure works even if the installation is done using two different users (usually oracle e grid). Always validate any procedure before you try it in a production environment. Scenario B - GRID Binaries Corrupted On ol8-19-rac2 After Patch Apply In this scenario, only the GRID binaries were affected, so let's try to preserve the DB binaries. The stack is already down since the binaries are corrupted. 01. Backup the OCR configuration
================================
As root, at any other node, create a OCR's backup. Better safe than sorry.


<anode gridenv root>
[root@ol8-19-rac2 scripts]# ocrconfig -manualbackup
ol8-19-rac2     2022/11/17 13:40:44     +CRS:/ol8-19-cluster/OCRBACKUP/backup_20221117_134044.ocr.258.1121002845     896235792


02. Check whether both nodes are unpinned (they must be Unpinned to proceed)
============================================================================
<anode gridenv>
[oracle@ol8-19-rac1 ~]$ olsnodes -s -t
ol8-19-rac1     Active  Unpinned
ol8-19-rac2     Active  Unpinned

If the node is pinned, then run the crsctl unpin css.


03. Backup the $ORACLE_HOME/network/admin
=========================================
<bnode gridenv>
[oracle@ol8-19-rac2 ~]$ mkdir -p /tmp/oracle; tar cvf /tmp/oracle/grid_netadm.tar -C $ORACLE_HOME/network/admin .


04. Deinstall the GRID binaries
===============================
<bnode gridenv>
[oracle@ol8-19-rac2 ~]$ $ORACLE_HOME/deinstall/deinstall -local
Confirm whether everything is OK, then say yes.

After, execute  the root step on another prompt.
[root@ol8-19-rac2 ~]# /u01/app/19.0.0/grid/crs/install/rootcrs.sh -force  -deconfig -paramfile "/tmp/deinstall2022-11-17_01-49-44PM/response/deinstall_OraGI19Home1.rsp"
...
2022/11/17 13:58:09 CLSRSC-336: Successfully deconfigured Oracle Clusterware stack on this node

Now, press enter to continue and finish the deinstall.


05. Remove the broken node from the cluster
===========================================
<anode gridenv root>
[root@ol8-19-rac1 ~]# crsctl delete node -n ol8-19-rac2
CRS-4661: Node ol8-19-rac2 successfully deleted.


06. Remove the broken node's VIP
================================
<anode gridenv root>
[root@ol8-19-rac1 ~]# srvctl stop vip -vip ol8-19-rac2
[root@ol8-19-rac1 ~]# srvctl remove vip -vip ol8-19-rac2
Please confirm that you intend to remove the VIPs ol8-19-rac2 (y/[n]) y


07. Check if the cluster is OK after the node removal
=====================================================
<anode gridenv>
[oracle@ol8-19-rac1 ~]$ cluvfy stage -post nodedel -n ol8-19-rac2 -verbose

Performing following verification checks ...

  Node Removal ...
    CRS Integrity ...PASSED
    Clusterware Version Consistency ...PASSED
  Node Removal ...PASSED

Post-check for node removal was successful.

CVU operation performed:      stage -post nodedel
Date:                         Nov 17, 2022 2:04:22 PM
Clusterware version:          19.0.0.0.0
CVU home:                     /u01/app/19.0.0/grid
Grid home:                    /u01/app/19.0.0/grid
User:                         oracle
Operating system:             Linux5.4.17-2136.312.3.4.el8uek.x86_64


08. Pre node addition validation
================================
If we were adding an actual new node, we were supposed to run some cluster verification checks to confirm that everything is OK, but since the node was already part of the cluster, I usually skip this validation, but you can execute it, if you want.

[oracle@ol8-19-rac1 ~]$ cluvfy stage -pre nodeadd -n ol8-19-rac2 -verbose -fixup


09. Add the node back
=====================
From any other node, add the ex-broken node back. This step takes a while, as it copies the files from one node to another.

<anode gridenv>
[oracle@ol8-19-rac1 ~]$ $ORACLE_HOME/addnode/addnode.sh -silent "CLUSTER_NEW_NODES={ol8-19-rac2}" "CLUSTER_NEW_VIRTUAL_HOSTNAMES={ol8-19-rac2-vip}" "CLUSTER_NEW_NODE_ROLES={hub}"

On the ex-broken node, execute the root script
<bnode root>
[root@ol8-19-rac2 tmp]# /u01/app/19.0.0/grid/root.sh


10. Check if the cluster is OK
==============================
From any other node, run the cluster verification.

<anode grid>
[oracle@ol8-19-rac1 ~]$ cluvfy stage -post nodeadd -n ol8-19-rac2 -verbose
...
Post-check for node addition was successful.


CVU operation performed:      stage -post nodeadd
Date:                         Nov 17, 2022 2:32:12 PM
Clusterware version:          19.0.0.0.0
CVU home:                     /u01/app/19.0.0/grid
Grid home:                    /u01/app/19.0.0/grid
User:                         oracle
Operating system:             Linux5.4.17-2136.312.3.4.el8uek.x86_64 Voilà, your cluster, and your database are supposed to be back online. [oracle@ol8-19-rac2 ~]$ crsctl check cluster -all
**************************************************************
ol8-19-rac1:
CRS-4537: Cluster Ready Services is online
CRS-4529: Cluster Synchronization Services is online
CRS-4533: Event Manager is online
**************************************************************
ol8-19-rac2:
CRS-4537: Cluster Ready Services is online
CRS-4529: Cluster Synchronization Services is online
CRS-4533: Event Manager is online
**************************************************************

[oracle@ol8-19-rac2 ~]$ srvctl status database -db cdbrac
Instance cdbrac1 is running on node ol8-19-rac1
Instance cdbrac2 is running on node ol8-19-rac2 In my next article, I'll show you how to recover from a scenario where we lost both GRID and DB binaries.

Fixing Oracle RAC Node Problems With Addnode: GRID Binaries

I’ve spent the last few weeks learning about compose and decided to write a post to share my notes. This post is not meant to teach you everything about Compose but rather it’ll be more like a roadmap that you can use to learn Compose or to see what you still don’t know about Compose. This article will be constantly updated as I learn new things. State hoisting State hoisting is a pattern of moving state up to make a component stateless. When applied to composables, this often means introducing two parameters to the composable. value: T – the current value to display onValueChange: (T) -> Unit – an event that requests the value to change, where T is the proposed new value CompositionLocal Tool for passing data down through the Composition implicitly. CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.medium) {
  Text(...)
}
CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.disabled) {
  Icon(...)
  Text(...)
} compositionLocalOf Changing the value provided during recomposition invalidates only the content that reads its current value. data class Elevations(val card: Dp = 0.dp, val default: Dp = 0.dp)
val LocalElevations = compositionLocalOf { Elevations() } // Create composition with default value

val elevations = Elevations(card = 4.dp, default = 2.dp) // Provide different value here
CompositionLocalProvider(LocalElevations provides elevations) { ... } staticCompositionLocalOf Reads of a are not tracked by Compose. Changing the value causes the entirety of the content lambda where the CompositionLocal is provided to be recomposed. staticCompositionLocalOf If the value provided to the CompositionLocal is highly unlikely to change or will never change, use to get performance benefits. staticCompositionLocalOf Keeping track of changes remember A value computed by remember will be stored in the composition tree, and only be recomputed if the keys to remember change. When adding memory to a composable, always ask yourself “will some caller reasonably want to control this?” If the answer is yes, make a parameter instead. If the answer is no, keep it as a local variable. Remember stores values in the Composition, and will forget them if the composable that called remember is removed. This means you shouldn’t rely upon remember to store important things inside of composables that add and remove children such as . LazyColumn rememberSaveable It behaves similarly to remember, but the stored value will survive the activity or process recreation using the saved instance state mechanism rememberUpdatedState In some situations you might want to capture a value in your effect that, if it changes, you do not want the effect to restart. Create a reference to this value which can be captured and updated. rememberLauncherForActivityResult val result = remember { mutableStateOf<Bitmap?>(null) }
val launcher = rememberLauncherForActivityResult(ActivityResultContracts.TakePicturePreview()) {
  result.value = it
}

Button(onClick = { launcher.launch() }) { ... }

result.value?.let { image ->
  Image(image.asImageBitmap(), null, modifier = Modifier.fillMaxWidth())
} rememberCoroutineScope In order to launch a coroutine outside of a composable, but scoped so that it will be automatically canceled once it leaves the composition is used for scoping jobs initiated by the composition. is for scoping jobs initiated by a user interaction. LaunchedEffect rememberCoroutineScope LaunchedEffect Call suspend functions safely from inside a composable. The coroutine will be cancelled if LaunchedEffect leaves the composition. If LaunchedEffect is recomposed with different keys, the existing coroutine will be cancelled and the new suspend function will be launched in a new coroutine. val currentOnTimeout by rememberUpdatedState(onTimeout)

LaunchedEffect(true) {
  delay(SplashWaitTimeMillis)
  currentOnTimeout()
} snapshotFlow Convert Compose State<T> objects into a Flow. DisposableEffect DisposableEffect is meant for side effects that need to be cleaned up after the keys change or the composable leaves the Composition. DisposableEffect(dispatcher) {
  dispatcher.addCallback(backCallback)
  onDispose {
    backCallback.remove()
  }
} derivedStateOf derivedStateOf is used when you want a Compose State that’s derived from another State. State Holder State holders always need to be in order to keep them in the Composition and not create a new one every time. It’s a good practice to create a method in the same file that does this to remove boilerplate and avoid any mistakes that might occur. remembered Layouts LazyColumn and LazyRow Don’t recycle their children like RecyclerView. It emits new Composables as you scroll through it and is still performant as emitting Composables is relatively cheap compared to instantiating Android Views. val listState = rememberLazyListState()

LazyColumn(
  contentPadding,
  verticalArrangement / horizontalArrangement = Arrangement.spacedBy
) {
  stickyHeader { Header()  } // Experimental
  items(5) { index -> Text(text = "Item: $index") } // key = ...
  item { Text(text = "Last item") }
}

LaunchedEffect(listState) {
  snapshotFlow { listState.firstVisibleItemIndex }
}

firstVisibleItemIndex
firstVisibleItemScrollOffset

scrollToItem()
animateScrollToItem() ConstraintLayout ConstraintLayout {
  val (button, text) = createRefs()

  Button(
    modifier = Modifier.constrainAs(button) {
      top.linkTo(parent.top, margin = 16.dp)
    }
  )

  Text("Text", Modifier.constrainAs(text) {
    top.linkTo(button.bottom, margin = 16.dp)
  })
}

ConstraintSet {
  val button = createRefFor("button")
  val text = createRefFor("text")

  constrain(button) { ... }
  constrain(text) { ... }
} Layout Instead of controlling how a single composable gets measured and laid out on the screen, you might have the same necessity for a group of composables. For that, you can use the Layout composable to manually control how to measure and position the layout’s children. Layout(
  modifier = modifier,
  content = content
) { measurables, constraints ->
  // Don't constrain child views further, measure them with given constraints
  val placeables = measurables.map { measurable -> measurable.measure(constraints) }

  // Set the size of the layout as big as it can
  layout(constraints.maxWidth, constraints.maxHeight) {
    var yPosition = 0

    placeables.forEach { placeable ->
      placeable.placeRelative(x = 0, y = yPosition)
      yPosition += placeable.height
    }
  }
} Intrinsic measurements Row(modifier = modifier.height(IntrinsicSize.Min)) Navigation val navController = rememberNavController()
val backstackEntry = navController.currentBackStackEntryAsState()

NavHost(navController = navController, startDestination = "profile") {
  composable(
    "profile/{userId}/?mode={mode}",
    arguments = listOf(
      navArgument("userId") { type = NavType.StringType },
      navArgument("mode") { defaultValue = "lite" },
    ),
    deepLinks = listOf(navDeepLink {
      uriPattern = "rally://$accountsName/{name}"
    })
  ) { 
    Profile(/*...*/) 
  }
  
  loginGraph()
}

fun NavGraphBuilder.loginGraph(navController: NavController) {
  navigation(startDestination = "username", route = "login") {
    composable("username") { ... }
  }
}

navController.navigate("friends") {
  popUpTo("home") { inclusive = true }
}

navController.navigate(screen.route) {
  // Pop up to the start destination of the graph to avoid building up a large stack 
  // of destinations on the back stack as users select items
  popUpTo(navController.graph.findStartDestination().id) {
    saveState = true
  }
  // Avoid multiple copies of the same destination when reselecting the same item
  launchSingleTop = true
  // Restore state when reselecting a previously selected item
  restoreState = true
} ViewModel @HiltViewModel
class ExampleViewModel @Inject constructor(
  ...
) : ViewModel() { /* ... */ }

@AndroidEntryPoint
class ExampleActivity : AppCompatActivity()

@Composable
fun ExampleScreen(
  exampleViewModel: ExampleViewModel = viewModel()
) { /* ... */ } Animation You can create an animation value by simply wrapping the changing value with the corresponding variant of composables. animate*AsState Float, Color, Dp, Size, Bounds, Offset, Rect, Int, IntOffset, and IntSize You can combine multiple transition objects with a + operator. MutableTransitionState(false).apply {
  targetState = true  // Start the animation immediately
  // isIdle, currentState
} AnimatedVisibility Content within (direct or indirect children) can use the animateEnterExit modifier to specify different animation behavior for each of them. AnimatedVisibility AnimatedContent defines how the size should animate between the initial and the target contents. SizeTransform animateContentSize Animates a size change Crossfade Animates between two layouts with a crossfade animation. Animatable Animatable is a value holder that can animate the value as it is changed via . animateTo sets the current value to the target value immediately. snapTo starts an animation that slows down from the given velocity. animateDecay val color = remember { Animatable(Color.Gray) }
LaunchedEffect(ok) { color.animateTo(if (ok) Color.Green else Color.Red) }InfiniteTransition InfiniteTransition Holds one or more child animations like Transition, but the animations start running as soon as they enter the composition and do not stop unless they are removed. Use the function. rememberInfiniteTransition Transition Transition manages one or more animations as its children and runs them simultaneously . between multiple states var currentState by remember { mutableStateOf(BoxState.Collapsed) }
val transition = updateTransition(currentState)

// Start in collapsed state and immediately animate to expanded
var currentState = remember { MutableTransitionState(BoxState.Collapsed) }
currentState.targetState = BoxState.Expanded
val transition = updateTransition(currentState)

transition.AnimatedVisibility
transition.AnimatedContent AnimationSpec spring(
  dampingRatio = Spring.DampingRatioHighBouncy,
  stiffness = Spring.StiffnessMedium
)

tween(
  durationMillis = 300,
  delayMillis = 50,
  easing = LinearOutSlowInEasing
)

// animates based on the snapshot values specified at different timestamps
keyframes {
  durationMillis = 375
  0.0f at 0 with LinearOutSlowInEasing // for 0-15 ms
  0.2f at 15 with FastOutLinearInEasing // for 15-75 ms
  0.4f at 75 // ms
  0.4f at 225 // ms
}

// runs a animation repeatedly until it reaches the specified iteration count
repeatable(
  iterations = 3,
  animation = tween(durationMillis = 300),
  repeatMode = RepeatMode.Reverse
)

// like repeatable, but it repeats for an infinite amount of iterations
infiniteRepeatable(
  animation = tween(durationMillis = 300),
  repeatMode = RepeatMode.Reverse
)

// immediately switches the value to the end value
snap(delayMillis = 50) Theming When defining colors, we name them “literally”, based on the color value, rather than “semantically” e.g. Red500 not primary. This enables us to define multiple themes e.g. another color might be considered primary in dark theme or on a differently styled screen. isSystemInDarkTheme() / MaterialTheme.colors.isLight color: Color = MaterialTheme.colors.surface, contentColor: Color = contentColorFor(color) When setting the color of any elements, prefer using a Surface to do this as it sets an appropriate content color value, be wary of direct Modifier.background calls which do not set an appropriate content color. CompositionLocal TextFieldDefaults textFieldColors outlinedTextFieldColors ProvideTextStyle So how do components set a theme typography style? Under the hood they use the composable (which itself uses a CompositionLocal) to set a “current” TextStyle. The Text composable defaults to querying this “current” style if you do not provide a concrete textStyle parameter. ProvideTextStyle Resources stringResource(R.string.congratulate, "New Year", 2021)
dimensionResource(R.dimen.padding_small)

painterResource(id = R.drawable.ic_logo)
animatedVectorResource(id = R.drawable.animated_vector)

Icon(Icons.Rounded.Menu) Fonts private val light = Font(R.font.raleway_light, FontWeight.W300)
private val regular = Font(R.font.raleway_regular, FontWeight.W400)
private val medium = Font(R.font.raleway_medium, FontWeight.W500)
private val semibold = Font(R.font.raleway_semibold, FontWeight.W600)

// Create a font family to use in TextStyles
private val craneFontFamily = FontFamily(light, regular, medium, semibold) buildAnnotatedString buildAnnotatedString {
  append("This is some unstyled text\\n")
  withStyle(SpanStyle(color = Color.Red)) {
    append("Red text\\n")
  }
  pushStringAnnotation(tag = "URL", annotation = "<https://developer.android.com>")
  withStyle(SpanStyle(fontSize = 24.sp)) {
    append("Large text")
  }
  pop()
} Generic Modifiers align
alignBy

// animateEnterExit modifier can be used for any direct or indirect children 
// of AnimatedVisibility to create a different enter/exit animation than 
// what's specified in AnimatedVisibility.
animateEnterExit(enter, exit)

border
background
clip
clipToBounds

drawBehind
drawWithCache
drawWithContent

// The draw layer can be invalidated separately from parents. 
// scaleX, scaleY, rotationXYZ, alpha, shadowElevation, shape, clip, shape
// Use with state values such as ScrollState or LazyListState
graphicsLayer

shadow
zIndex

onKeyEvent

// Creates a LayoutModifier that allows changing how the wrapped element is 
// measured and laid out.
layout

absoluteOffset
offset

fillMaxHeight, fillMaxWidth, fillMaxSize
// matches the size of the Box after all other children have been measured 
// to obtain the Box's size.
matchParentSize

heighIn(min, max), widthIn(min, max) Gesture Modifiers combinedClickable(onLongClick, onDoubleClick, onClick)

draggable(
  orientation = Orientation.Horizontal,
  state = rememberDraggableState { delta ->
    val newValue = offsetPosition.value + delta
    offsetPosition.value = newValue.coerceIn(minPx, maxPx)
  }
)

swipeable(
  state = swipeableState,
  anchors = anchors,
  thresholds = { _, _ -> FractionalThreshold(0.3f) },
  orientation = Orientation.Horizontal
)

pointerInput(Unit) {
  detectTapGestures(onPress, onDoubleTap, onLongPress, onTap)
  detectDragGestures { change, dragAmount ->
    change.consumeAllChanges()
    offsetX += dragAmount.x
    offsetY += dragAmount.y
  }
}

horizontalScroll, verticalScroll

// Detects the scroll gestures, but does not offset its contents.
// Has nested scroll built in
scrollable

nestedScroll(nestedScrollConnection, nestedScrollDispatcher) Miscelaneous LocalSoftwareKeyboardController val keyboardController = LocalSoftwareKeyboardController.current
// Calling this function is considered a side-effect and should not be called directly from recomposition
keyboardController.hide() LocalOnBackPressedDispatcherOwner and BackHandler var backHandlingEnabled by remember { mutableStateOf(true) }
var backPressedCount by remember { mutableStateOf(0) }
BackHandler(backHandlingEnabled) { backPressedCount++ }

val dispatcher = LocalOnBackPressedDispatcherOwner.current!!.onBackPressedDispatcher

Button(onClick = { dispatcher.onBackPressed() }) {
  Text("Press Back count $backPressedCount")
} LocalDensity val sizeInPx = with(LocalDensity.current) { 16.dp.toPx() }
val (minPx, maxPx) = with(LocalDensity.current) { min.toPx() to max.toPx() } FocusRequester val focusRequester = remember { FocusRequester() }
var color by remember { mutableStateOf(Black) }
Box(
  Modifier
    .clickable { focusRequester.requestFocus() }
    .border(2.dp, color)
    // The focusRequester should be added BEFORE the focusable.
    .focusRequester(focusRequester)
    // The onFocusChanged should be added BEFORE the focusable that is being observed.
    .onFocusChanged { color = if (it.isFocused) Green else Black }
    .focusable()
) Thank you for reading. If you have any suggestions feel free to contact me. Resources https://developer.android.com/jetpack/compose/architecture https://developer.android.com/jetpack/compose/resources https://developer.android.com/jetpack/compose/animation https://developer.android.com/jetpack/compose/gestures https://developer.android.com/jetpack/compose/navigation https://developer.android.com/jetpack/compose/modifiers-list https://developer.android.com/jetpack/compose/mental-model https://developer.android.com/jetpack/compose/compositionlocal https://developer.android.com/codelabs/jetpack-compose-basics https://developer.android.com/codelabs/jetpack-compose-layouts https://developer.android.com/codelabs/jetpack-compose-state https://developer.android.com/codelabs/jetpack-compose-theming https://developer.android.com/codelabs/jetpack-compose-animation https://developer.android.com/codelabs/jetpack-compose-navigation https://developer.android.com/codelabs/jetpack-compose-advanced-state-side-effects https://developer.android.com/reference/kotlin/androidx/compose/runtime/saveable/package-summary Also published . here

The Ultimate Jetpack Compose Cheat Sheet

Introduction This article shows you how to add a back button to your react navbar. It shows you how to show / hide the back button, how to change its icon, how to handle the callback and then how to do further styling. Prerequisites This article assumes that you have read the previous navbar tutorials. In case you haven't you will find a consolidated list in the reference links section. This article assumes that you have installed the Superflows library, have the default navigation bar up and running, have added your brand information, have also customised your menu, have added the search input, have configured the sign in button and have also understood how to insert user profile information into the navbar. This tutorial takes it forward from there. Step 1 - Display the Back Button By default, the menu button is shown and the back button is not shown. To show the back button, set the showBack prop to true. Please note that after the back button is displayed, the menu button is not shown. Only one of these two buttons can be shown at one time. Usually the back button on the navbar will be required on the inner screens, where the menu, search and sign in button may also not be required. You can remove them as well. function Apps(props) {

    return (
        <div>
            <div>
                <SfNav 
                  showBack={true} 
                  menu={[]} 
                  showSearch={false} 
                  showSignIn={false} 
                />
            </div>
        </div>
    );
} Step 2 - Change the Icon You can change the back icon by passing your own icon object to the backIcon prop. This example uses an icon from the React Bootstrap icon library. You can use any other icon library as well. import {ArrowLeft} from 'react-bootstrap-icons' function Apps(props) {

    return (
        <div>
            <div>
                <SfNav 
                  showBack={true} 
                  menu={[]} 
                  showSearch={false} 
                  showSignIn={false} 
                  backIcon={<ArrowLeft style={{paddingTop: '5px'}} />}
                />
            </div>
        </div>
    );
} Step 3 - Handle the Button Press Callback You can receive a callback after user presses the back button, after subscribing to the onBackPressed prop. function Apps(props) {

    return (
        <div>
            <div>
                <SfNav 
                  showBack={true} 
                  onBackPressed={() => {alert('back pressed');}} 
                  menu={[]} '    
                  showSearch={false} 
                  showSignIn={false} 
                />
            </div>
        </div>
    );
} Step 4 - Styling If you are interested in obtaining complete control over the look and feel, you already have it. You can completely override the base css properties of the back icon. An example is show below: function Apps(props) {

    return (
        <div>
            <div>
                <SfNav 
                  showBack={true} 
                  onBackPressed={() => {alert('back pressed');}} 
                  menu={[]} 
                  showSearch={false} 
                  showSignIn={false} 
                  stylesBack={{backgroundColor: 'black', color: 'white', padding: '0px', width: '20px', height: '20px', textAlign: 'center', lineHeight: '1.1', borderRadius: '10px', marginRight: '10px'}} 
                  />
            </div>
        </div>
    );
} Reference Links Documentation This link Example Project For This Tutorial This link Previous Tutorials of Navbar T1: Getting Started With Navbar T2: Insert Brand Info T3: Customise Menu T4: Add Search Functionality T5: Add Sign In Button T6: Insert User Profile Info YouTube Channel This link Discord Community This link Example Projects Collection This link Video Tutorial https://www.youtube.com/watch?v=r8VIwvYWOCU?embedable=true Further Reading You have already seen how to get started with the navigation bar, how to insert brand information into it, how to customise the menu and now, how to configure the search input, how to use the sign in button, how to insert profile information into it and now, how to add a back button. Conclusion This article shows you how to add back button into your react navigation bar, how to change the back icon, how to handle its callback and how to style it. Also published . here

Adding a Back Button to your React Navbar

Organizing an application based on multiple activities may not always be optimal. The Android OS world is quite fragmented and consists of many devices. And if for mobile devices with small screens the interaction between different activities looks pretty good, then on large screens - tablets, TVs, activity windows would not look very good due to the large screen size. That's why the concept of fragments appeared. A fragment represents a piece of the application's visual interface that can be reused and reused. A fragment can have its layout file, fragments have their lifecycle. A fragment exists in the context of activity and has its life cycle; it cannot exist outside the activity in isolation. Each activity can have multiple fragments. Fragments cannot live on their own-they must be by activity or another fragment. The Fragment also has its life cycle: hosted Let’s create Fragment. To do this, we need to create layout files for them and classes with an ancestor androidx.fragment.app.Fragment : fragment1.xml <?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#77ff0000"
    android:orientation="vertical">
    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Fragment 1">
    </TextView>
</LinearLayout> : Fragment1.kt class Fragment1: Fragment() {

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        Log.e(TAG, "onCreateView: ")
        return inflater.inflate(R.layout.fragment1, container, false)
    }
} In the onCreateView method, the system asks us what to display inside the fragment. We tell the system that we want to see the contents of the corresponding layout file in the fragment. To do this, we ourselves create a View using inflater and give it to the system. Those. in meaning, this is an analog of the setContentView method, which we call in the Activity. Only here do we have to create the View ourselves, and not just pass the layout file ID. For interaction between fragments, the class is used - a special fragment manager. androidx.fragment.app.FragmentManager FragmentManager uses FragmentTransaction for adding, deleting, and other actions with a fragment to conduct a transaction Before starting a transaction, you need to get an instance of via the method. Next, various methods are called to manage the fragments. FragmentTransaction FragmentManager.beginTransaction() At the end of any transaction, which may consist of a chain of the above methods, the method should be called. commit() val fragmentManager = supportFragmentManager
fragmentManager.beginTransaction()
    .remove(fragment1)
    .add(R.id.fragment_container, fragment2)
    .show(fragment3)
    .hide(fragment4)
    .commit() FragmentTransaction Methods add() Adds a fragment to an activity Removes a fragment from an activity remove() Replaces one fragment with another replace() Hides the fragment (makes it invisible on the screen) hide() Displays a hidden fragment on the screen show() (API 13) Detaches the fragment from the GUI, but the class instance is retained detach() (API 13) Attaches a fragment that has been detached by the method attach() detach() Now we add the Fragment to Activity class MainActivity : AppCompatActivity() {


	override fun onCreate(savedInstanceState: Bundle?) {  
	    super.onCreate(savedInstanceState)  
	    setContentView(R.layout.activity_main)
		
		val fragmentManager = supportFragmentManager
		fragmentManager.beginTransaction()
			.add(R.id.fragment_container, Fragment1())
		    .commit()
	}

} A fragment must have only one empty constructor with no arguments. But you can create a static with arguments via the method. newInstance setArguments() class Fragment1 : Fragment() {

	...

	companion object {  
	  
	    private const val KEY = "VALUE_KEY"  
	  
	    fun newInstance(value: String) = Fragment1().apply {  
	        arguments = Bundle().apply {  
	            putString(KEY, value)  
	        }  
	    }  
	}
}

class MainActivity : AppCompatActivity() {


	override fun onCreate(savedInstanceState: Bundle?) {  
	    super.onCreate(savedInstanceState)  
	    setContentView(R.layout.activity_main)
		
		val fragmentManager = supportFragmentManager
		fragmentManager.beginTransaction()
			.replace(R.id.fragment_container, Fragment1.newInstance("some text "))
		    .commit()
	}

} The arguments can be accessed in the method of the fragment: onCreate() override fun onCreate(savedInstanceState: Bundle?) {  
    super.onCreate(savedInstanceState)  
    
	val text = requireArguments().getString(KEY, "")
	
} Fragment stack management Fragments, like activities, can be controlled by the button. You can add several fragments, and then use the button to return to the first fragment. If no fragments remain on the stack, then the next button press will close the activity. Back Back To add a transaction to the stack, call the method before committing the transaction. The string argument is an optional name to identify the stack, or . The class has a method that returns the previous stack state by that name. FragmentTransaction.addToBackStack(String) null FragmentManager popBackStack() val fragmentManager = supportFragmentManager
		fragmentManager.beginTransaction()
			.replace(R.id.fragment_container, Fragment1.newInstance("some text "))
			.addToBackStack(null)
		    .commit() If you call the method when removing or replacing a fragment, then the fragment methods will be called. addToBackStack() onPause(), onStop(), onDestroyView() When the user presses the back button, the fragment methods , , and are called. onCreateView() onActivityCreated() onStart() onResume() Let's consider an example of reacting to the button in a fragment without using the stack. The activity has an method that responds to the button being pressed. We can refer to the desired fragment in this method and call it the fragment method. Back onBackPressed() Summary The Fragment is a very interesting Android component and is quite easy to use and fast. I hope the article helped to understand the main points and how to use Fragment. In the first part of the article, I briefly talked about the main points on Fragments, in the next part of the article we will talk about the new Fragment API and its methods.

Understanding Fragments in Android: Part 1

Don’t you think that a great many mobile apps would be a lot more convenient if they had voice control? And I don’t mean chatting with a banking bot. In most cases, voice navigation or a conversational form-filling is just enough. Through the use of the example (an open-source Kotlin-based habit tracking app) Vit Gorbachyov, Just AI solution architect, will show you how to add a voice interface into any app swiftly and seamlessly. Habitica How convenient does that sound? Let’s start with the obvious: It’s really often that we need to use apps when our hands are full – when we cook, drive, carry a suitcase, etc. Voice is a major instrument for people with vision disabilities. It’s really obvious, but most of the time voice is simply quicker. Consider this, ordering a ticket saying instead of a long-time form filling. With an option of clarification questions – should that be morning or evening? Will there be luggage or not? get me a plane to London for tomorrow for two Voice is very useful in a form-filling scenario and it suits perfectly almost any long forms, requiring lots of info from a user. And these are the kind of forms that almost any mobile app has. Most companies keep trying to stuff all the functionality they can think of into a chat because usually voice assistants are embedded into chat support. You know, to refill the balance, get the item or service info, etc. It’s not always convenient, sometimes it’s even counterproductive because voice recognition is yet not perfect. The right approach here is to embed an assistant into the already existing app functionality. So we took as an example – it’s perfect for a voice assistant addition because in order to create a new task you have to fill in the long form. Let’s try to swap out this dreary process to one phrase with some guiding questions. Habitica What we need to get started . We use to create dialog interfaces. It’s an open-source voice assistant SDK with ready to use . You can use built-in and components and or you can create your own suite. SDK Aimybox customizable UI speech to text text to speech NLU implementations Aimybox implements the assistant’s architecture, standardizes interfaces, and organizes mutual support. So, you can really cut down the time it takes to develop a voice interface. . We will use open-source Kotlin-based chatbot and voice assistant development framework (Just AI Conversational Framework), which is totally free. (an NLU service) inside the (Just AI Conversational Platform) would help us with intent recognition. Tools to create a scenario JAICF Caila JAICP I’m covering these tools in the . There I show how to manage an application with voice only –invoking certain screens, implementing complex queries within the app, and changing habits. next part of this tutorial . We will need an Android phone to test the Habitica solution. Smartphone Action plan We start with a project fork – we take the Release development branch and look for the most essential files. I used the IDE Android Studio: .kt – that’s where we build the logic in. MainActivity .kt – that’s where we will initiate Aimybox HabiticaBaseApplication .xml — that’s where the interface element will be   AndroidManifest.xml — that’s where the app’s structure and its permissions are stored Activity_main According to Habitica’s repository instruction, we rename and by taking the out. Then we start a new firebase project and copy the file to the root node. habitica.properties.example habitica.resources.example example google-services.json Now we start the app to see whether it works. Ta-dah! To begin with, we add Aimybox dependencies. implementation implementation( ) 'com.justai.aimybox:core:0.11.0' "com.justai.aimybox:components:0.1.8" to dependencies maven { url }
  maven { url } 'https://dl.bintray.com/aimybox/aimybox-android-sdk/' "https://dl.bintray.com/aimybox/aimybox-android-assistant/" and repositories. And right after compileOptions we add the following lone so that everything works properly. kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    } Now the permissions. We take the flags off in and in .xml, so that the options look like that RECORD_AUDIO MODIFY_AUDIO_SETTINGS AndroidManifest <uses-permission android:name= /> <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="com.android.vending.BILLING" />
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/> "android.permission.READ_PHONE_STATE" < = /> uses-permission android:name "android.permission.ACCESS_NETWORK_STATE" Now we initiate Aimybox in a BaseApplication.  Adding AimyboxProvider at the component initialization And initializing: private fun createAimybox (context: Context): Aimybox {
        val unitId = UUID.randomUUID().toString()
        val textToSpeech = GooglePlatformTextToSpeech(context, Locale( ))
        val speechToText = GooglePlatformSpeechToText(context, Locale( ))
        val dialogApi = AimyboxDialogApi( , unitId) Aimybox(Config.create(speechToText, textToSpeech, dialogApi))
    } "Ru" "Ru" "YOUR KEY" return Afterward, instead of YOUR_KEY, you will see your Aimybox Console code. Now we build in a fragment into mainActivity.kt. We embed FrameLayout in activity_main.xml tentatively, right under the FrameLayout with id bottom_navigation <FrameLayout
             android:id= android:layout_width= android:layout_height= /> "@+id/assistant_container" "match_parent" "match_parent" Into the MainActivity we add OnCreate explicit request permissions ActivityCompat.requestPermissions( , arrayOf(android.Manifest.permission.RECORD_AUDIO), ) this 1 And when we get it, we add the fragment into the frame mentioned above. @SuppressLint( )
    override fun onRequestPermissionsResult(
            requestCode: Int, : <out >, : IntArray
    ) {
        val fragmentManager = supportFragmentManager
        val fragmentTransaction = fragmentManager.beginTransaction()
        fragmentTransaction.add(R.id.assistant_container, AimyboxAssistantFragment())
        fragmentTransaction.commit()
    } "MissingPermission" permissions Array String grantResults Don’t forget to add an option to log out the assistant after you’ve logged in into OnBackPressed. val assistantFragment = (supportFragmentManager.findFragmentById(R.id.assistant_container) ? AimyboxAssistantFragment) (assistantFragment?.onBackPressed() != ) { } as if true return Besides, we add styles to styles.xml in AppTheme <item name= >@style/CustomAssistantButtonTheme< CustomRecognitionWidgetTheme< CustomResponseWidgetTheme< CustomImageReplyWidgetTheme< CustomButtonReplyWidgetTheme< "aimybox_assistantButtonTheme" /item>
        <item name="aimybox_recognitionTheme">@style/ /item>
        <item name="aimybox_responseTheme">@style/ /item>
        <item name="aimybox_imageReplyTheme">@style/ /item>
        <item name="aimybox_buttonReplyTheme">@style/ /item> And some custom styles a bit underneath: <style name= parent= > <style name= parent= > <style name= parent= > <style name= parent= > <style name= parent= > "CustomAssistantButtonTheme" "DefaultAssistantTheme.AssistantButton" </ > style "CustomRecognitionWidgetTheme" "DefaultAssistantTheme.Widget.Recognition" </ > style "CustomResponseWidgetTheme" "DefaultAssistantTheme.Widget.Response" </ > style "CustomButtonReplyWidgetTheme" "DefaultAssistantTheme.Widget.ButtonReply" </ > style "CustomImageReplyWidgetTheme" "DefaultAssistantTheme.Widget.ImageReply" </ > style Now let’s see whether the mic has appeared. Launching an application. Okay, we got plenty of syntactic errors. We correct everything as IDE says. Aaaaand it works! But the mic slipped down the navigation. Let’s give it a lift. Let’s add this to the styles in CustomAssistantButtonTheme: <item name= > dp< "aimybox_buttonMarginBottom" 72 /item> That’s better! Now we switch in the assistant to see whether it responds well. We will need the Aimybox console for that. We go to app.aimybox.com using Github acc, create a new project, add a couple of skills (I’ve added DateTime for testing purpose), and try asking questions. Using settings in the upper right corner we take apiKey and add it to createAimybox instead of YOUR KEY. private fun createAimybox (context: Context): Aimybox {
        val unitId = UUID.randomUUID().toString()
        val textToSpeech = GooglePlatformTextToSpeech(context)
        val speechToText = GooglePlatformSpeechToText(context)
        val dialogApi = AimyboxDialogApi( , unitId) Aimybox(Config.create(speechToText, textToSpeech, dialogApi))
    } "YOUR KEY" return It works! Here’s a repository link Read the second part Previously published at https://just-ai.com/en/blog/how-to-add-a-voice-assistant-to-your-mobile-app

How to Add a Voice Assistant to your Mobile App?

In this tutorial, we will learn . How to Convert a Website into an Android Application using Android Studio If you do not know anything about Android Studio yet, Don’t worry.We will start everything from scratch. This is how the website looks like: And the Android app, we developed using Android Studio looks like: Before we begin: If you downloaded Android Studio and already installed in your system then you can skip the part and Go to direct the coding part. NOTE: : If not Download Android Studio Google provides Android Studio for the Windows, Mac OS X, and Linux platforms. You can from the Android Studio homepage. download this software Before downloading Android Studio, make sure your platform meets one of the following requirements:**Windows OS**Microsoft Windows 7/8/10 (32-bit or 64-bit)2 GB RAM minimum, 8 GB RAM recommended2 GB of available disk space minimum, 4 GB Recommended (500 MB for IDE + 1.5 GB for Android SDK and emulator system image)1280 x 800 minimum screen resolutionFor accelerated emulator: 64-bit operating system and Intel processor with support for Intel VT-x, Intel EM64T (Intel 64), and Execute Disable (XD) Bit functionality **Mac OS**Mac OS X 10.8.5 or higher, up to 10.11.4 (El Capitan)2 GB RAM minimum, 8 GB RAM recommended2 GB of available disk space minimum, 4 GB Recommended (500 MB for IDE + 1.5 GB for Android SDK and emulator system image)1280 x 800 minimum screen resolutionJDK 6 : Tested on Ubuntu 12.04, Precise Pangolin (64-bit distribution capable of running 32-bit applications)64-bit distribution capable of running 32-bit applicationsGNU C Library (glibc) 2.11 or later2 GB RAM minimum, 8 GB RAM recommended2 GB of available disk space minimum, 4 GB Recommended (500 MB for IDE + 1.5 GB for Android SDK and emulator system image)1280 x 800 minimum screen resolutionJDK 8For accelerated emulator: Intel processor with support for Intel VT-x, Intel EM64T (Intel 64), and Execute Disable (XD) Bit functionality, or AMD processor with support for AMD Virtualization (AMD-V) Linux OSGNOME or KDE desktop Installing Android Studio on 64-bit Windows 8.1 Figure 1. Set up Android Studio Figure 2. Do you want to install the Android SDK and AVD? Figure 3. Accept the license agreement to continue the installation Figure 4. Set the Android Studio and Android SDK installation locations Figure 5. Create a new shortcut for Android Studio To complete your installation, leave the Start Android Studio box checked and click Finish. Figure 6. Leave the Start Android Studio checkbox checked to run this software Running Android Studio Android Studio presents a splash screen when it starts running: If you’re like me and don’t have a previously installed version, you can just keep the default setting and click OK. Figure 9. Validate your Android SDK and development environment setup When you click Next, the setup wizard invites you to select an installation type for your SDK components. For now, I recommend you keep the default standard setting. Figure 10. Choose an installation type Figure 11. Review settings The wizard will download and unzip various components. Click Show Details if you want to see more information about the archives being downloaded and their contents. Figure 12. The wizard downloads and unzips Android Studio components Your options are to either put up with the slow emulator or use an Android device to speed up development. I’ll discuss the latter option later in the tutorial. Finally, click Finish to complete the wizard. You should see the Welcome to Android Studio dialog box: Figure 14. Welcome to Android Studio You’ve installed and configured Android Studio and created a project for your first Android Studio mobile app; now you’re ready to build your Android application. In Android Studio, this means populating your new project with Java source code and resource files. Your first Android Studio mobile app Starting a new project From our setup so far, you should still have Android Studio running with the Welcome to Android Studio dialog box. From here, click Start a new Android Studio project. Android Studio will respond with the Create New Project dialog box shown in Figure. Figure 15. Create a new project Figure 16. Select your target device categories Click Next, and you will be given the opportunity to choose a template for your app’s main activity. For now, we’ll stick with Empty Activity. Select this template and click Next. Next, you’ll customize the activity: Enter as the activity name and as the layout name, and click Finish to complete this step. Android Studio will respond that it is creating the project, then take you to the project workspace. W2A main Figure 19. Android Studio workspace The project window is organized into a tree whose main branches are App and Gradle Scripts. The App branch is further organized into manifests, java, and res subbranches: stores AndroidManifest.xml, which is an XML file that describes the structure of an Android app. This file also records permission settings (where applicable) and other details about the app. manifests stores an app’s Java source files according to a package hierarchy, which is ca.javajeff.w2a in this example. java stores an app’s resource files, which are organized into drawable, layout, mipmap, and values subbranches: res : an initially empty location in which to store an app’s artwork drawable : a location containing an app’s layout files; initially, main.xml(the main activity’s layout file) is stored here layout : a location containing various ic_launcher.png files that store launcher screen icons of different resolutions mipmap : a location containing colors.xml, dimens.xml, strings.xml, and styles.xml values The Gradle Scripts branch identifies various .gradle (such as build.gradle) and .properties (such as local.properties) files that are used by the Gradle-based build system. Now the coding part will start… Add a webView to your activity as shown in the picture below. **layout/activity_main.xml** < > RelativeLayout xmlns:android=”http://schemas.android.com/apk/res/android"xmlns:tools=”http://schemas.android.com/tools" android:layout_width=”match_parent”android:layout_height=”match_parent”tools:context=”.MainActivity” < /> WebViewandroid:layout_width=”fill_parent”android:layout_height=”fill_parent”android:id=”@+id/webView”android:layout_alignParentLeft=”true”android:layout_alignParentStart=”true”android:layout_alignParentTop=”true”android:layout_alignParentRight=”true”android:layout_alignParentEnd=”true” </ > RelativeLayout src/main/AndroidManifest.xml_<? ?>_<manifest xmlns:android=”http://schemas.android.com/apk/res/android" package=”com.vinaysomawat.careerhigh”android:installLocation=”auto”><uses-permission android:name=”android.permission.INTERNET”/><applicationandroid:allowBackup=”true”android:icon=”@mipmap/faviconcircular”android:label=”@string/app_name”android:roundIcon=”@mipmap/faviconcircular”android:supportsRtl=”true”android:theme=”@style/AppTheme”> xml version=”1.0" encoding=”utf-8" <activity android:name=”.SplashActivity” android:theme=”@style/SplashTheme”><intent-filter><action android:name=”android.intent.action.MAIN” /><category android:name=”android.intent.category.LAUNCHER” /></intent-filter></activity><activity android:name=”.MainActivity” /></application></manifest> **MainActivity.java** **package com.vinaysomawat.careerhigh;** /*** Created by Vinay Somawat on 10-01-2019.*/ import android.support.v7.app.ActionBarActivity;import android.os.Bundle;import android.view.Menu;import android.view.MenuItem;import android.webkit.WebSettings;import android.webkit.WebView;import android.webkit.WebViewClient; public class MainActivity extends ActionBarActivity {private WebView mywebview; @Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout. );mywebview = (WebView)findViewById(R.id. );WebSettings webSettings = mywebview.getSettings();webSettings.setJavaScriptEnabled(true);mywebview.loadUrl(“https://careerhigh.in");mywebview.setWebViewClient(new WebViewClient());} activity_main webView @Overridepublic void onBackPressed(){if(mywebview.canGoBack()) {mywebview.goBack();} else{super.onBackPressed();}} @Overridepublic boolean onCreateOptionsMenu(Menu menu){getMenuInflater().inflate(R.menu. , menu);return true;} menu_main @Overridepublic boolean onOptionsItemSelected(MenuItem item){int id = item.getItemId();if(id == R.id. ){return true;}return super.onOptionsItemSelected(item);}} action_settings **menu/menu_main.xml** < >< /></ > menu xmlns:android=”http://schemas.android.com/apk/res/android"xmlns:app=”http://schemas.android.com/apk/res-auto"xmlns:tools=”http://schemas.android.com/tools" tools:context=”.MainActivity” item android:id=”@+id/action_settings” android:title=”@string/action_settings”android:orderInCategory=”100" app:showAsAction=”never” menu **values/styles.xml** < > resources __    <**style name="AppTheme" parent="Theme.AppCompat.Light"**\>  
    __        <**item name="colorPrimary"**\>@color/colorPrimary</**item**\>  
    <**item name="colorPrimaryDark"**\>@color/colorPrimaryDark</**item**\>  
    <**item name="colorAccent"**\>@color/colorAccent</**item**\>  
</**style**\>  
<**style name="TextAppearance.AppCompat.Widget.ActionBar.Title" parent="android:TextAppearance"**\>  
    <**item name="android:textColor"**\>@color/titlecolour</**item**\>  
    <**item name="android:textSize"**\>30sp</**item**\>  
</**style**\> </ > resources **values/strings.xml** _?>_< > <? xml version="1.0" encoding="utf-8" resources <**string name="app\_name"**\>CareerHigh</**string**\>  
<**string name="hello\_world"**\>Hello world!</**string**\>  
<**string name="action\_settings"**\>Settings</**string**\> </ > resources **values/colors.xml** _?>_< >< >#000000</ >< >#303F9F</ >< >#FF4081</ >< >#398bb7</ ></ > <? xml version="1.0" encoding="utf-8" resources color name="colorPrimary" color color name="colorPrimaryDark" color color name="colorAccent" color color name="titlecolour" color resources Add a launching activity to App: (It looks nice) Launching Activity **SplashActivity.java** com.vinaysomawat.careerhigh; package _/*** Created by Vinay Somawat on 10-01-2019.*/_ android.content.Intent; android.os.Bundle; android.support.annotation.Nullable; android.support.v7.app.AppCompatActivity; import import import import SplashActivity AppCompatActivity { public class extends @Override  
**protected void** onCreate(@Nullable Bundle savedInstanceState) {  
    **super**.onCreate(savedInstanceState);  
    Intent intent = **new** Intent(**this**, MainActivity.**class**);  
    startActivity(intent);  
    finish();  
} } And add some code it values/styles.xml < >< >@drawable/background</ ></ > style name="SplashTheme" parent="Theme.AppCompat.NoActionBar" item name="android:windowBackground" item style create a file: drawable/background.xml _?>_< >< /> <? xml version="1.0" encoding="utf-8" layer-list xmlns:android="http://schemas.android.com/apk/res/android" item android:drawable="@color/colorPrimary" <**item**\>  
    <**bitmap android:src="@drawable/logo2"  
        android:gravity="center"** />  

</**item**\> </ > layer-list make sure you add a to folder to display in launching activity. sample image drawable OUTPUT: Now run your android app, and you will see the following result Finally, your first Android App is created. If you got stuck somewhere Download the Source Code Or use the following command: command-line >git clone https://github.com/vinaysomawat/CareerHigh-App And share your Android App with your friends. Did I get something wrong? Mention it in the comments. I would love to improve.If you learned even a thing or two, clap your hands 👏 as many times as you can to show your support!Hello World, I am Vinay Somawat. A creative developer and a logical designer. You can find me on Linkedin or stalk me on GitHub or maybe follow me on Twitter? If that’s too social for you, just drop a mail to vinaysomawat40@gmail.com if you wish to talk tech with me. Have a nice day!

Stories, News & Mentions about OWNBACKUP

Ownbackup’s Stories on HackerNoon